CgTutorial-Chapter1-2(1) the cg tutorial 中文

To put C g into its proper context, you need tounderstand how GPUs render images. This section explains howgraphics hardware is evolving and then explores the modern graphicshardware-rendering pipeline.

Computer graphics hardware is advancing atincredible rates. Three forces are driving this rapid paceof

innovation, as shown in Figure 1-2. First, thesemiconductor industry has committed itself to doublingthe

number of transistors (the basic unit of computerhardware) that fit on a microchip every 18 months. This

constant redoubling of computer power,historically known as Moore's Law, means cheaper andfaster

computer hardware, and is the norm for ourage.

The second force is the vast amount of computationrequired to simulate the world around us. Our eyes consume and ourbrains comprehend images of our 3D world at an astounding rate andwith startling acuity. We are unlikely ever to reach a point wherecomputer graphics becomes a substitute for reality. Reality is justtoo real. Undaunted, computer graphics practitioners continue torise to the challenge. Fortunately, generating images is anembarrassingly parallel problem. What we mean by "embarrassinglyparallel" is that graphics hardware designers can repeatedly splitup the problem of creating realistic images into more chunks ofwork that are smaller and easier to tackle. Then hardware engineerscan arrange, in parallel, the ever-greater number of transistorsavailable to execute all these various chunks of work.

Our third force is the sustained desire we allhave to be stimulated and entertained visually. This is the forcethat "connects" the source of our continued redoubling of computerhardware resources to the task of approximating visual reality evermore realistically than before.

As Figure 1-2 illustrates, these insights let usconfidently predict that computer graphics hardware is going to getmuch faster. These innovations whet our collective appetite formore interactive and compelling 3D experiences. Satisfying thisdemand is what motivated the development of the C glanguage.

A pipeline is a sequence of stages operating in parallel andin a fixed order. Each stage receives its input from the priorstage and sends its output to the subsequent stage. Like anassembly line where dozens of automobiles are manufactured at thesame time, with each automobile at a different stage of the line, aconventional graphics hardware pipeline processes a multitude ofvertices, geometric primitives, and

fragments in a pipelined fashion.

Figure 1-3 shows the graphics hardware pipelineused by today's GPUs. The 3D application sends the GPU a sequenceof vertices batched into geometric primitives: typically polygons,lines, and points. As shown in Figure 1-4, there are many ways tospecify geometric primitives.

Every vertex has a position but also usually hasseveral other attributes such as a color, a secondary (orspecular) color, one or multiple texture coordinate sets,and a normal vector. The normal vector indicates what direction thesurface faces at the vertex, and is typically used in lightingcalculations.

Vertex transformation is the first processing stage in the graphicshardware pipeline. Vertex transformation performs a sequence ofmath operations on each vertex. These operations includetransforming the vertex position into a screen position for use bythe rasterizer, generating texture coordinates for texturing, andlighting the vertex to determine its color. We will explain many ofthese tasks in subsequent chapters.

The transformed vertices flow in sequence to thenext stage, called primitive assembly andrasterization. First, the primitive assembly step assemblesvertices into geometric primitives based on thegeometric

primitive batching information that accompaniesthe sequence of vertices. This results in a sequence of triangles,lines, or points. These primitives may require clipping tothe view frustum (the view's visible region of 3D space), as wellas any enabled application-specified clip planes. The rasterizermay also discard polygons based on whether they face forward orbackward. This process is known as culling.

Polygons that survive these clipping and cullingsteps must be rasterized. Rasterization is the process ofdetermining the set of pixels covered by a geometric primitive.Polygons, lines, and points are each rasterized according to therules specified for each type of primitive. The results ofrasterization are a set of pixel locations as well as a set offragments. There is no relationship between the number of verticesa primitive has and the number of fragments that are generated whenit is rasterized. For example, a triangle made up of just threevertices could take up the entire screen, and therefore generatemillions of fragments!

Earlier, we told you to think of a fragment as apixel if you did not know precisely what a fragment was. At thispoint, however, the distinction between a fragment and a pixelbecomes important. The term pixel is short for "picture element." A pixel representsthe contents of the frame buffer at a specific location, such asthe color, depth, and any other values associated with thatlocation. A fragment is the state required potentially to update aparticular pixel.

and one or more texture coordinate sets. Thesevarious interpolated parameters are derived from the transformedvertices that make up the particular geometric primitive used togenerate the fragments. You can think of a fragment as a "potentialpixel." If a fragment passes the various rasterization tests (inthe raster operations stage, which is described shortly), thefragment updates a pixel in the frame buffer.

Once a primitive is rasterized into a collectionof zero or more fragments, the interpolation, texturing, and coloringstage interpolates the fragment parameters asnecessary, performs a sequence of texturing and math operations,and determines a final color for each fragment. In addition todetermining the fragment's final color, this stage may alsodetermine a new depth or may even discard the fragment to avoidupdating the frame buffer's corresponding pixel. Allowing for thepossibility that the stage may discard a fragment, this stage emitsone or zero colored fragments for every input fragment itreceives.

The raster operations stage performs a final sequence of per-fragmentoperations immediately before updating the frame buffer. Theseoperations are a standard part of OpenGL and Direct3D. During thisstage, hidden surfaces are eliminated through a process knownas depth testing. Other effects, such as blending andstencil-based shadowing, also occur during this stage.

The raster operations stage checks each fragmentbased on a number of tests, including the scissor, alpha, stencil,and depth tests. These tests involve the fragment's final color ordepth, the pixel location, and per-pixel values such as the depthvalue and stencil value of the pixel. If any test fails, this stagediscards the fragment without updating the pixel's color value(though a stencil write operation may occur). Passing the depthtest may replace the pixel's depth value with the fragment's depth.After the tests, a blending operation combines the final color ofthe fragment with the corresponding pixel's color value. Finally, aframe buffer write operation replaces the pixel's color with theblended color. Figure 1-5 shows this sequence ofoperations.

Figure 1-5 shows that the raster operations stageis actually itself a series of pipeline stages. In fact, all of thepreviously described stages can be broken down into substages aswell.

Figure 1-6 depicts the stages of the graphicspipeline. In the figure, two triangles are rasterized. The processstarts with the transformation and coloring of vertices. Next, theprimitive assembly step creates triangles from the vertices, as thedotted lines indicate. After this, the rasterizer "fills in" thetriangles with fragments. Finally, the register values from thevertices are interpolated and used for texturing and coloring.Notice that many fragments are generated from just a fewvertices.