Model Clipping Triangle Strips and Quad Meshes.

Patrick-Gilles Maillot

Sun Microsystems, Inc. 2550 Garcia Avenue, Mountain View, CA 94043

Abstract This paper describes an original software implementation of 3D homogeneous Model Clipping for Triangle Strips and Quadrilateral Meshes. After a definition of these graphics entities, and a study of their geometrical characteristics, the different possible situations when clipping triangles is presented. The detailed description of the kernel of the algorithm, optimized for clipping triangle strips is made, followed by the specific cases that can be found when dealing with quadrilateral meshes. Precisions are given concerning memory usage of the proposed method, and a complete implementation of the algorithm for triangle strips in the C language follows. The conclusion includes some performance numbers that can be expected from the given algorithm.

CR categories and Subject Descriptors: I.3.3 [Computer Graphics]: Picture/Image Generation, Display algorithms, Viewing algorithms; Additional Key Words and Phrases: 3D Polygon Clipping, Triangle Strips, Quadrilateral Meshes.

Model Clipping Triangle Strips and Quad Meshes. Introduction. One can easily find in the literature1, 2, 4 some information on how to perform clipping of general 3D graphics primitives, such as lines and polygons. With the graphics system architectures currently available, the term “polygon” often refers to triangles or quads packed together in more complex structures such as triangle strips and quad meshes. It is generally when using these primitives that the best drawing performance can be achieved on most of the advanced graphics systems5, 6. One of the most expensive operation in graphics is to perform clipping. Distinction can be made between Model Clipping, where the clipping planes can be arbitrarily oriented, and View Clipping, where the number of clipping planes, as well as their orientation, is fixed. This article proposes a solution that takes into account the specific organization of Triangles Strips and Quad Meshes primitives in order to achieve efficient Model Clipping. Some of the principles discussed here can be applied to other, simpler, graphic structures such as multi-bounded polygons, in order to improve the efficiency of standard clipping methods. The general solution proposed for the clipping equations can also be simplified in order to perform View Clipping of the same primitives7.

Data Study. An easy way of optimizing a graphics pipeline operations is not to modify the structure of the primitive all along the graphics pipeline. Unfortunately, some operations of the pipeline can modify, or break, the logical structure of the initial primitive. This is typically the case of clipping, where a triangle of a triangle strip can be changed (clipped) into a n-sided polygon, after being clipped by (n-3) planes, breaking the structure of the initial triangle strip. This paper proposes a general approach to the clipping of triangle strips in the case of 3D homogeneous coordinates and arbitrary oriented clipping planes. The particularities of the extension to the clipping of quad meshes are also detailed. The proposed method accepts a single triangle strip structure at the input of the clipping process, and returns a single triangle strip structure at the output. In the case of quad meshes, the quads are clipped row by row, and the clipping process can return multiple rows of quads for a single row of quad at the input. While described by “a list of points”, triangle strips do have a logical organization that should be considered during the clipping step. A triangle strip consists of an ordered list of n vertices {v0, v1,..., vn-1} that define a sequence of n-2 triangles. The triangles in the strip share common edges. Thus, the kth triangle is formed of vertices k, k+1, k+2. On

the other hand, a quad mesh consists of a matrix of m rows and n columns (m, n > 1) of vertices stored as an ordered list of (mn) vertices {v00, v01,..., v0(n-1), v10,..., v(m-1)0, v(m-1)1,..., v(m-1)(n-1)}.A quad mesh, as described here, defines (m-1)(n-1) quads qk, (k=0, (m-1)(n-1) -1) formed from each square of adjacent vertices vij, vi(j+1),v(i+1)j, v(i+1)(j+1), where i = km, and j = k mod (n). The quads are drawn in the order qk, (k=0, (m-1)(n-1) -1). Figure 1 gives a pictorial examples of a single triangle strip and a quad mesh.

1

00 01

02

03

3

0

10

2

20

5

4

30

6

40 7

8

50 60

9 10

Figure 1: A single triangle strip and a simple quad mesh

Algorithm Study. We propose to clip the primitives using a method derived from the Sutherland-Hodgman algorithm1. This means that the clipping calculations will be limited to determining intersections with one clipping plane at a time, separating the primitive into two regions: the inside and the outside. These calculations will be repeated as many times as needed to scan all the enabled clipping planes. The Sutherland-Hodgman method involves a lot of computations as well as memory operations. However, since we define our Model space as a 3D homogeneous space, and the vertices can have both normal and color information, it seems to be the most efficient. Each intersection (computed only when needed) is based on the parametric equation of the edge from one vertex to another: R = λQ + ( 1 – λ )P , λ ∈ [ 0,0 , 1,0 ]

The value of λ is used to compute the intersection vertex coordinates (R), and can also be used to linearly interpolate per vertex color and/or normal data if needed. The intersection, in the case of a line segment such as P→Q, has to be evaluated only when the end points of that line lie in opposite regions. If a bit is assigned to each point, with a 1 meaning “lies outside” and a 0 meaning “lies inside”, then the intersection will be computed only when (bit[P] exclusive-or bit[Q]) is set, meaning that one point lies outside and the other one lies inside the clipping region. If both bits are set, that means the entire line segment is outside the clipping region. The entire line segment is inside the clipping region when both bits are equal to 0. This approach, presented in 3, offers the advantage of using fast operations to check for trivial cases, and provides a way to keep intermediate results available for the next point. In the case of a triangle, we can take advantage of three points at a time and for quads, four points can be considered two by two. A Model Clipping plane is defined by a 3D point and a normal vector, both expressed in the Model Space. Some graphics packages specify the clipping planes in World Coordinates8, 9, but it is always possible to transform the clipping planes so that they are defined in Model Space Coordinates, thus simplifying the graphics pipeline to be the following:

Primitive in Model coordinates ↓ Model Clipping ↓ Transformation to NPC ↓ View Clipping ↓ Division by W ↓ Transformation to DC ↓ Rendering

Let C be a model clipping plane, 4

4

C: { S ∈ R , N ∈ R } , S = ( Sx, S y, S z, 1 ) ,a point of C in 3D Model Space, and N = ( Nx, N y, N z, 0 ) , a unit vector normal to C.

In fact, a single vector can be used to fully define the clipping plane, as shown in10, let E be that vector: 4

E ∈ R , and E = ( N x, N y, N z, – ( S x ⋅ N x + S y ⋅ N y + S z ⋅ N z ) ) . 4

T

Then P: P ∈ R , P = ( x, y, z, w ) is inside the half-space defined by C if E P ≥ 0 .

T

T

There will be clipping of the segment P→Q if sign ( E P ) ≠ sign ( E Q ) , that is if P and Q are on opposite sides of C. Figure 2 graphically presents different possible situations for both P and Q in respect to C. A point exactly on the clipping plane is considered inside the half-space.

P

P Q

N

N

S

N

S

C

S

C

C

Q P & Q on opposite sides of C

P

Q

P & Q on identical sides of C

Figure 2: Possible situations of P & Q in respect to C .

When there is intersection, P and Q are on opposite sides of C. The intersection point R must satisfy two equations: R must belong to the line segment P→Q: R = λQ + ( 1 – λ )P , and T

R must belong to the plane C: E R = 0 .

The case of triangle strips. A triangle strip is (obviously) composed of triangles. Each triangle can be considered separately for the intersection calculations. However, the implementation of the clipping algorithm should provide a way to avoid multiple equivalent calculations by taking advantage of the logical organization of the vertices. Because a triangle is composed of three points, and each point can be either inside, or outside a given half-space, there are 8 different situations when computing the clipped result of a triangle with a single clipping plane. Each case generates a particular sequence of

points at the output of the clipping process. This process will be repeated as many times as Model Clipping planes to clip against. Figure 3 shows the different cases and the resulting output that has to be generated by the Model Clipping in order to maintain the initial organization of the triangle strip.

Clip codes [k, i, j]

output sequence of points j

j 000 i

i, j, k i

k

k j

j k

a

001

a, j, c, j, k

c

k

a 110

i

i

i, a, c, c *

c a

010 i

b

i

k

i, a, k, b, k

k j

j 101

a

a, j, b

b

j

j

b

100

i

i

i, j, k, j, b

k

b k

011 c

k

c, c, b, k * (* see text)

111

Figure 3: triangle situations, the gray areas represent the rejecting half-space.

In order to maintain the triangle strip structure, the triangle strip Model Clipping algorithm can generate some triangles with an area of zero. By doing this, the triangle strip structure can be maintained even when a triangle degenerates into a quad after clipping with a clip-plane. There are special cases, when clipping a triangle with clipping codes

equal to 011 or 110 (Figure 3, cases marked *). The code 110 indicates that the current triangle has its two last points outside the current half-space, and the first point of the triangle is inside the current half-space, so the triangle strip is “leaving” the visible half-space. The code 011 indicates the opposite situation, the triangle strip “enters” again, or for the first time, the visible half-space. In this particular case, a new triangle strip should be issued. Even in the case of a single triangle strip input, it is possible to generate more than one triangle strip after the clipping operation. Figure 4 gives further detail, explaining such a situation. There is a way, however, to avoid generating multiple triangle strips at the model clipping output in order to still be able to take advantage of an accelerated renderer. The solution proposed in the case presented in Figure 4, is to duplicate points Q and R so that three degenerate triangles (e.g. triangles with an area of 0) are issued to keep the logic of the original triangle strip. In that particular case, these triangles would be (P, Q, Q), (Q, Q, R), (Q, R, R). The implementation presented later in this paper takes advantage of this method. It should be noted that this can be applied only when the rendering stage, further “down” in the graphics pipeline, knows how to deal with degenerate triangles.

j

P i

Q k m

a

R

... i, j, k: clipping code 110, generates i, P, Q j, k, m: clipping code 111, culled k, m, a: clipping code 111, culled m, a, b: clipping code 111, culled a, b, c: clipping code 011, generates R, S, c ...

c

S

b A new triangle should be issued when clipping a, b, c

Figure 4: Multiple triangle strips created by the clipping operation.

The case of quad meshes. The same principle that has been presented for triangle strip can be applied to quad meshes11. In the quad mesh case,

however, a single quad can generate 16 different cases depending on the situation of the four points of the quad in respect to a model clipping plane. Also, a single row of quads will generate one or several rows of quads and the clipping of quad meshes can only generate a subset, or special case of the quad mesh primitive. Figure 5 shows some examples of quads situation where the clipping operation has to generate several rows of quads at the output. Quad meshes are generally organized such that it is easy to isolate a complete row; but the order in which the points appear for a given row can impact the efficiency of the clipping operation. This because the implementation presented here is based on the same principle than in the case of triangle strips, and expects to be able to “shift” the information concerning the last two points of the current quad in order for them to become the first two points of the next quad.

S

Q

initial quad

Q

P

b

c

d R

0110, generates: Q, a, d, a, new row, d, c, d, R

a

b

Q c Figure 5: New row generation cases.

1001, generate: a, P, a, c, new row, b, d, S, d

1110, generates: Q, a, b, a, new row

b

Q

a c

d

a

R

P

S

b

1100, generates: Q, P, b, c, new row

P

Memory considerations. The standard clipping algorithm proposed by Sutherland-Hodgman implies a lot of memory or stack operations. A detailed introduction to the principle of the algorithm is presented in2, showing the different steps used to clip a polygon, in 2D, or 3D. Although it is mentioned that the reentrant characteristic of the original algorithm avoids the need for intermediate storage, the cost implied in stack operations and recursive calls is probably not well suited in the case of a software implementation with large data structures. While keeping the same general intersection principles, this article proposes a different approach, necessitating intermediate storage, but limiting the number of inner loops of the clipping algorithm to the number of active clipping

planes. The algorithm first builds a list of pointers to the original points, provided by the caller. It then only propagates pointers to points, and not the points themselves, from one stage of the clipper to the next stage, thus avoiding expensive memory copy operations. When the generation of new points is made necessary because of an actual intersection with a clipping plane, the algorithm saves the intersection point in a “point stack” and keeps the pointer to that point for use in the next clipping stages. Finally, when all the clipping planes have been scanned, an output list of points is build from the current list of pointers.

Implementation. The algorithm proposed here supports the case where the W components of the vertices of the triangle strip are positive. Model Clipping for negative w’s requires to change the clipping equation in the implementation proposed below (this exercise is left to the reader), and supporting lines with end vertices having both positive and negative w’s require two passes by the clipping algorithm in order to render both positive and negative sections, one for each clipping equation. Figure 6 shows the result of clipping a single triangle with coordinates being (1,0,0,1), (0,1,0,1), and (0,0,1,1) compared to a triangle with coordinates being (1,0,0,1), (0,1,0,-1), and (0,0,1,-1). It has been shown12 that under certain circumstances, the coordinate system in which clipping is perform may influence the number of passes that have to be done in order to consider both positive and negative w’s. In fact this is true only in the case vertices in the negative space are generated because of the special nature of the projection transform. It is still necessary to perform two distinct passes when the data initially contains both positive and negative w components.

x 1,0,0,1

0,0,1,1

0,0,1,-1

z

z y

x 0,1,0,1

a) All w components are positive.

Figure 6: Effect of Positive and Negative w components.

1,0,0,1

y 0,1,0,-1

b) w components are positive and negative

The following is an example of implementation of the model clipping for triangle strips, based on the principles presented in this article. For simplification purposes, the vertex structures contain only coordinates data. They can easily be modify to take into account color and/or normal information, in which case, the intersection macros should also be modified. The structure H_point is used to store the point coordinates, H_list represents a list of points. The model clipping planes are represented by a structure of type H_plane, containing the 4 significant elements of a model clipping plane. Clip_ctx represents the context state information used by the algorithm. It contains storage for defining a list of clipping planes, and arrays of points or pointers to points. These arrays should be initialized to null pointers and the corresponding number of elements should be set to 0.

#define MEM_INCREMENT 64 /* * 3D point structure */ typedef struct { float coords[4]; } H_point; typedef struct { int num_hpoints; H_point *hpoints; } H_list; typedef struct { float normal[3]; float cst; } H_plane; typedef struct { H_plane *Mclip_planes; int num_planes; H_point **pointers_bucket_0; int pointers_bucket_0_max; H_point **pointers_bucket_1; int pointers_bucket_1_max; H_point *hpoints_bucket; int hpoints_bucket_max; int hpoints_bucket_index; } Clip_ctx; /* * * Space coding information: * * This 3D clipping function is based on the intersection of * lines using a line segment parametric equation: * * Let P a point on the line segment, then if A and B are the * extremes points of the line segment, we can write: * P = l * B + (1 - l) * A, with l = [0..1] * A 0 bit means “interior”, while * a 1 bit means “exterior”. * */ /* * Intersection macros

*/ #define COMPUTE_INTER_3D(P, P_plan, S) \ P = pre_stage[n]; \ P_plan = P->coords[0] * plane->normal[0] + \ P->coords[1] * plane->normal[1] + \ P->coords[2] * plane->normal[2] - \ P->coords[3] * plane->cst; \ clip_code |= ((P_plan < 0.) << S);

#define POINT_INTER_3D(P, P_plan, Q, Q_plan) \ if (clip_ctx->hpoints_bucket_index >= clip_ctx->hpoints_bucket_max) { \ if (clip_ctx->hpoints_bucket) { \ C = (H_point *)realloc(clip_ctx->hpoints_bucket, \ (clip_ctx->hpoints_bucket_max + MEM_INCREMENT) * sizeof(H_point)); \ } else { \ C = (H_point *)malloc((clip_ctx->hpoints_bucket_max + MEM_INCREMENT) \ * sizeof(H_point)); \ } \ if (C) { \ clip_ctx->hpoints_bucket_max += MEM_INCREMENT; \ clip_ctx->hpoints_bucket = C; \ } else { \ out->num_hpoints = 0; \ return; \ } \ } \ lambda = P_plan / (P_plan - Q_plan); \ C->coords[0] = P->coords[0] + lambda * (Q->coords[0] - P->coords[0]); \ C->coords[1] = P->coords[1] + lambda * (Q->coords[1] - P->coords[1]); \ C->coords[2] = P->coords[2] + lambda * (Q->coords[2] - P->coords[2]); \ C->coords[3] = P->coords[3] + lambda * (Q->coords[3] - P->coords[3]); \ cur_stage[n_cur_s] = C; \ n_cur_s += 1; \ clip_ctx->hpoints_bucket_index += 1; \ C += 1; #define POINT_COPY(P) \ cur_stage[n_cur_s] = P; \ n_cur_s += 1;

/* * h3d_strip_clip: * 3D triangle strip clipper. A triangle strip is made of * vertices logocally organized in triangles (...). The first * triangle is composed of the vertices 0, 1, and 2. The second * triangle is represented by the vertices 1, 2, and 3, and so * on until the last vertex. * As presented in the algorithm, a triangle strip outputs only * one triangle strip. This is possible if degenerate triangles * are acceptable. * * Notes: * This is basically a Sutherland-Hodgman algorithm. But a non-recursive * version. */ h3d_strip_clip(clip_ctx, in, out) register Clip_ctx *clip_ctx; register H_list *in; register H_list *out;

{ register register register register register register double float

H_point H_point H_plane int int unsigned char

**pre_stage, **cur_stage, **tmp_stage; *P, *Q, *R, *C; *plane; n_pre_s, n_cur_s, n_cur_max; i, n; clip_code; lambda; P_plan, Q_plan, R_plan;

/* * At init, set the previous stage point to the input points values. */ n_cur_s = in->num_hpoints; if (clip_ctx->pointers_bucket_0_max < (n_cur_s + MEM_INCREMENT)) { if (pre_stage = (H_point **)malloc((n_cur_s + MEM_INCREMENT) * sizeof(H_point *))) { if (clip_ctx->pointers_bucket_0) free(clip_ctx->pointers_bucket_0); clip_ctx->pointers_bucket_0 = pre_stage; clip_ctx->pointers_bucket_0_max = n_cur_s + MEM_INCREMENT; } else { out->num_hpoints = 0; return; } } if (clip_ctx->pointers_bucket_1_max < (n_cur_s + MEM_INCREMENT)) { if (pre_stage = (H_point **)malloc((n_cur_s + MEM_INCREMENT) * sizeof(H_point *))) { if (clip_ctx->pointers_bucket_1) free(clip_ctx->pointers_bucket_1); clip_ctx->pointers_bucket_1 = pre_stage; clip_ctx->pointers_bucket_1_max = n_cur_s + MEM_INCREMENT; } else { out->num_hpoints = 0; return; } } cur_stage = clip_ctx->pointers_bucket_0; for (i = 0; i < n_cur_s; i++) cur_stage[i] = &(in->hpoints[i]); C = clip_ctx->hpoints_bucket; clip_ctx->hpoints_bucket_index = 0; /* * For each of the clipping plane, clip (if necessary). */ plane = clip_ctx->Mclip_planes; for (i = 0; (i < clip_ctx->num_planes && n_cur_s > 2); i++, plane++) { /* * switch memory between current and previous. */ pre_stage = cur_stage; n_pre_s = n_cur_s; if (cur_stage == clip_ctx->pointers_bucket_0) { cur_stage = clip_ctx->pointers_bucket_1; n_cur_max = clip_ctx->pointers_bucket_1_max; } else { cur_stage = clip_ctx->pointers_bucket_0; n_cur_max = clip_ctx->pointers_bucket_0_max; } n_cur_s = 0; /*

* Start clipping of the previous stage, for the ith clip plane. * Output points go in the current_stage memory. */ /* * Start clipping of the triangle strip from the “previous” stage * into the “current” stage, for the ith clip plane. * * Process the first point of the triangle strip. * */ clip_code = 0; n = 0; COMPUTE_INTER_3D(Q, Q_plan, 1) /* * Now, process the second point of the triangle strip. */ n = 1; COMPUTE_INTER_3D(R, R_plan, 2) /* * (Q, R) represents the first line segment of the first triangle of * the triangle strip. We need to clip it as a line * to ensure the first two points of the triangle. */ n = clip_code >> 1; switch (n) { case 0: /* Q and R inside */ POINT_COPY(Q) POINT_COPY(R) break; case 1: /* Q outside, R inside */ POINT_INTER_3D(Q, Q_plan, R, R_plan) POINT_COPY(R) break; case 2: /* Q inside, R outside */ POINT_COPY(Q) POINT_INTER_3D(Q, Q_plan, R, R_plan) break; case 3: /* Q and R outside */ default: break; } /* * Process each subsequent point of the triangle strip. * P, Q, R form the (n-2)ith triangle of the strip. */ for (n = 2; n < n_pre_s; n++) { clip_code >>= 1; P = Q; Q = R; P_plan = Q_plan; Q_plan = R_plan;

COMPUTE_INTER_3D(R, R_plan, 2) /* * We need to ensure that enough memory is available. */ if (n_cur_max < n_cur_s + 3) { tmp_stage = (H_point **)realloc(cur_stage, (n_cur_max + MEM_INCREMENT) * sizeof (H_point *)); if (tmp_stage) { if (cur_stage == clip_ctx->pointers_bucket_0) { clip_ctx->pointers_bucket_0_max += MEM_INCREMENT; } else { clip_ctx->pointers_bucket_1_max += MEM_INCREMENT; } } else { out->num_hpoints = 0; return; } cur_stage = tmp_stage; n_cur_max += MEM_INCREMENT; } /* * clip_code has now 3 bits that represent the “situation” of the triangle * in respect to the clip boundary. 8 different cases can occur. */ switch (clip_code) { case 0: /* all inside */ POINT_COPY(R) break; case 1: /* P outside, Q and R inside */ POINT_INTER_3D(R, R_plan, P, P_plan) POINT_COPY(Q) POINT_COPY(R) break; case 2: /* P inside, Q outside and R inside */ POINT_COPY(R) POINT_INTER_3D(Q, Q_plan, R, R_plan) POINT_COPY(R) break; case 3: /* P and Q outside, R inside */ POINT_INTER_3D(R, R_plan, P, P_plan) memcpy((char *)(cur_stage + n_cur_s), (char *)(cur_stage + n_cur_s - 1), sizeof(H_point)); n_cur_s += 1; POINT_INTER_3D(Q, Q_plan, R, R_plan) POINT_COPY(R) break; case 4: /* P and Q inside, R outside */ POINT_INTER_3D(R, R_plan, P, P_plan) POINT_COPY(Q) POINT_INTER_3D(Q, Q_plan, R, R_plan) break; case 5: /* P outside, Q inside, R outside */ POINT_INTER_3D(Q, Q_plan, R, R_plan)

break; case 6: /* P inside, Q and R outside */ POINT_INTER_3D(R, R_plan, P, P_plan) memcpy((char *)(cur_stage + n_cur_s), (char *)(cur_stage + n_cur_s - 1), sizeof(H_point)); n_cur_s += 1; break; case 7: /* P, Q and R outside */ default: break; } } } /* * The triangle strip has been clipped against all (enabled) clipping * planes. * “Copy” the result to the output. */ if (n_cur_s > 2) { for (i = 0; i < n_cur_s; i++) out->hpoints[i] = *(cur_stage[i]); out->num_hpoints = n_cur_s; } else { out->num_hpoints = 0; } return; }

Conclusion. This article has presented a different approach to 3D homogeneous clipping of complex primitives. Most of the particularities presented here: re-organization of the Sutherland-Hodgman algorithm, intersection computations, nonuniform clipping volume, etc. can be used in any 3D homogeneous polygon clipping. The performance of the proposed algorithm is better that 89,000 triangles per second for trivial acceptance and better than 114,000 triangles per second for trivial reject on a Sun-Sparc station 330, with the C program given in the previous paragraph, for one model clipping plane and triangle strips of 10 or more triangles. The efficiency of the clipping algorithm varies with the number of planes and the number of triangles per triangle-strip. The worst case of the algorithm -one triangle per triangle strip- still clips at an honorable speed of 32,000+ triangles per second. The specific case of single triangles should be optimized separately. An implementation optimized for View

Clipping7, 11 and limited to the clipping against uniform volumes (boundaries have fixed values, -1.0, 0.0, or +1.0) gives also better performances. The method presented here has also been applied in the case of quadrilateral meshes. The clipping operation is performed one quad-mesh row at a time, and can generate several quad-mesh rows at the output of the clipping algorithm11. Because quads are composed of four points, the algorithm takes two points at a time, and the core of the clipping process necessitates 16 different cases.

Bibliography:

1

Sutherland, I. E, and Hodgman, G. W., 1974. “Reentrant Polygon Clipping,” CACM, 17 (1), 32-42.

2

Foley, vanDam, Feiner, Huges, 1990, “Computer Graphics, Principles and Practice,” Addison Welsey 12110.

3

Maillot, P. G., 1986, “Contribution à l’étude des systèmes graphiques: architectures logicielle et matérielle,” Ph.D. Thesis, University Claude Bernard, Lyon I, Lyon, France.

4

Newman, W.M., and Sproull, R.F., 1979, “Principles of Interactive Computer Graphics,” McGraw Hill.

5

Deering & al, 1988. “The Triangle Processor and Normal Vector Shader,” CACM, 22 (4), 21-30.

6

Akeley, K., and Jermoluk, T., 1988. “High Performance Polygon Rendering,” CACM, 22 (4), 239-246.

7

Arvo, J., 1991. “More Graphics Gems,” Academic Press.

8

PHIGS standard, 1988, Functional Description, International Standard ISO 9592.

9

XGL 2.0, 1991, Reference Manual and Programmers’ guide, Sun Microsystems, Inc.

10

Hübl, J. and Herman, I., 1990. “Modelling Clip: Some More Results,” Computer Graphics Forum 9, North Holland, 101-107.

11

Maillot, P.G., 1989. “Three Dimensional Homogeneous Clipping of Triangle Strips and Quadrilateral Meshes,” Sun Microsystems, Inc. internal document.

12

Abi-Ezzi, S., and Wozny, M.J., 1190. “Factoring a Homogeneous Transformation Pipeline for a more Efficient Graphics Pipeline,” Computer Graphics Forum 9, North Holland, 245-255.