JP2002074385A - Method and device for providing logic coupling for operating n alphas inside graphic system - Google Patents

Abstract

PROBLEM TO BE SOLVED: To generate powerful 2D and 3D graphics or surround sounds in a graphic system provided with a graphics and audio processor for specified use. SOLUTION: This system is provided with the graphics and audio processor equipped with a 3D graphics pipeline and an audio digital signal processor. While using logic coupling for comparing N alphas, a wide image processing effect including outlining of cartoon can be provided.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

The present invention relates to computer graphics, and more particularly, to interactive graphics systems, such as home video game platforms. Even more particularly, the present invention relates to using logical combinations of N alpha channel operations to produce interesting graphics effects including non-photorealistic images, such as cartoon outlining.

[0002]

2. Description of the Related Art Many of us have seen images containing fantastic creatures such as dinosaurs, aliens, and animated toys that are very realistic. Such animations are made possible by computer graphics. Using such techniques, computer graphics producers can specify what each object looks like and what appearance changes will occur over time. Then, the computer models the object and displays it on a display such as a television or a computer screen. The coloring and shape of each part of the displayed image is reliably and successfully performed based on the position and orientation of each object in the scene, the lighting direction for each object, the texture of the surface of each object, and various other factors Many tasks required by the computer are undertaken.

Due to the complexity of generating computer graphics, computer graphics were created only a few years ago.
The use of dimensional graphics was largely limited to expensive and specialized flight simulators, high-end graphics workstations, and supercomputers. People could see images generated by computer systems in movies and expensive television advertisements, but could not actually access the computer that performs the graphics generation. This change has been due to the advent of relatively inexpensive 3D graphics platforms, such as Nintendo 64 (registered trademark) and various 3D graphics cards available for personal computers. Now, even at home or at work, it is possible to interact with powerful 3D animations and simulations on a relatively inexpensive computer graphics system.

[0004] Most computer graphics research so far has tended to focus on producing realistic images. This research has been very successful. Computers can now generate images that are so realistic that they cannot be distinguished from photographs. For example, many of us have seen real dinosaurs, aliens, and computer-generated photorealistic special effects in movies and television. New pilots are training on a highly realistic computer-based flight simulator that approximates the actual flight. Now, low-cost home video game systems can offer a very high degree of realism, giving game players the ability to drive real racing cars on the stadium or ski on snow and ice. You can give the illusion of skiing down a slope or walking through a medieval castle. Many games greatly enhance the gameplay experience with these illusions of reality.

[0005] As one of methods for extending the sense of reality, there is a method of modeling the opacity (transparency) of a surface using a technique called "alpha blending". Using this prior art, each image element is assigned an "alpha value" representing the degree of opacity. The colors of the image elements can be blended based on the alpha value so that some objects can be seen through other objects. As still another conventional technique,
There is something called an "alpha function" or "alpha test", which can be used to discard an object fragment by comparing the alpha value of the object fragment to a reference function or value. The alpha test may also decide not to blend (ie, discard) what would be part of the image because it would be invisible because it is transparent.

[0006] Alpha blending and alpha testing are particularly useful for modeling transparent objects such as water and glass. This same function can be used with texture mapping to achieve various effects. For example, alpha tests are often used to draw complex shapes using texture maps on polygons, with alpha elements acting as mats. As an example, a tree can be drawn on a polygon as a picture (texture) of the tree. The tree portion of the texture image can have an alpha value of 1 (opaque), and the non-tree portion can have an alpha value of 0 (transparent). Thus, the "non-tree" portion of the polygon is mapped to the invisible (transparent) portion of the texture map, and the "tree" portion of the polygon is mapped to the visible (opaque) portion of the texture map.

[0007] Other uses of the alpha component of the texture include, for example, drilling holes and trimming surfaces. As an example, an image of a cutout or trim region can be stored in a texture map. When mapping a texture to a polygon surface, an area that has been cut out or trimmed from the polygon surface can be cut using alpha test or alpha blending. In addition, the alpha channel of a computer graphics system can be used to provide non-photorealistic image effects, such as cartoon outlining. 19
US patent application Ser. No. 09/46, filed Dec. 21, 1999.
The mechanism disclosed in US Pat. No. 8,109 uses the alpha channel of the real-time rendering system to encode identifiers corresponding to different objects and different object parts. In this system, an object is rendered in a color frame buffer and the corresponding object ID is written to an alpha frame buffer. An alpha test process is performed on the alpha frame buffer and the alpha comparison result (ie,
Using the absolute value of the difference between the two alpha values), a color scheme of a contour line surrounding a contour defined between a silhouette and an image region encoded with a different alpha / ID is selectively blended.

[0008] Typical commonly available 3D graphics application programmer interfaces, such as DirectX and OpenGL, support alpha comparison. This alpha comparison "kills" pixels that fail the comparison for transparency or by comparing iterative or texture alpha with a constant, for example.
It is for doing. As an example, Direct3D
Includes the "D3DRENDERSTATE ALPHATES" used to enable the alpha test.
A command “T-ENABLE” is prepared.
An enumeration, such as the command D3DCOMFUNC, allows the programmer to specify tests that would be used in an alpha comparison operation (eg, never, always, <,>, below, above, unequal, etc.).
For example, if the alpha comparison function is set to "greater than or equal to" and the pixel to be rasterized is more opaque than the color already present at the pixel, Direct3D will:
Skipping this completely saves the time it would take to blend the two colors and prevents the color and z buffers from being updated. Also, D3DR
The new alpha can also be compared to a reference alpha value specified by the programmer using the ENDSTATE_ALPHAREF command (e.g., "If,
If alpha <128/255, kill pixel "). For example, Kovac et al.
ct3D (Microsoft 2000) ", 289-291
See page. A similar alpha test / comparison function
GL_ALPHA_TEST, GL_ALPHA_TE
ST_FUNC, GL_ALPHA_TEST_REF
It is also prepared in OpenGL by a command. Neider et al., 301 in "OpenGL Programming Guide" (Addison-Wesley, 1993).
See ~ 302.

A problem that arises in performing various and complex alpha comparisons, including the cartoon outlining algorithm described above, is how efficient a more complex alpha comparison can be made in hardware using a single rendering pass. To do it. For example, alpha tests of arbitrary complexity can typically be performed directly by software executed by a processor, but are based on hardware-based alpha (eg, for faster performance). Sometimes it is desirable to use tests. Such arbitrarily complex alpha test features have heretofore not been normally available in low cost graphics systems such as home video games and graphics cards for personal computers.

The present invention solves this problem, and provides a hardware based pixel shader capable of performing multiple alpha comparisons that can be logically combined to provide a wide range of alpha test functions. Is to achieve. According to one aspect of the invention, a pixel shader can be used to provide a transparent tree similar to a shade tree. In particular, using the alpha function, N logical alpha operations can be performed on the M alpha input. Here, N and M may be any integers.

One aspect of the present invention provides a method for generating a graphics image, wherein information representing a surface to be imaged (the information includes alpha) is generated in the same rendering pass. Performing a plurality of alpha comparisons on the alpha information to provide a corresponding plurality of alpha comparison results, logically combining the plurality of alpha comparison results, at least partially based on the logical combination And rendering the graphics image. The rendering step may include selecting whether to kill pixels based on the logical combination. The performing steps may be performed in hardware and / or using a recirculating shader.

In accordance with another aspect of the present invention, a graphics system includes a texture portion including a texture coordinate matrix multiplier, a shader including an alpha channel, a built-in frame buffer capable of storing an alpha image, and a A copy-out pipeline for copying from the frame buffer to make the texture portion available as text, wherein the graphics system performs multiple alpha comparisons in a single rendering pass.

By using a combination of alpha comparison and alpha logic operations, a wide range of additional effects based on alpha can be achieved. For example, a double alpha comparison can be used to provide non-photorealistic effects such as cartoon outlining (eg, by implementing an absolute value function,
It is possible to efficiently determine whether or not to blend cartoon outline colors based on the logical combination).

[0014]

DETAILED DESCRIPTION FIG. 1 shows an example of an interactive 3D computer graphics system 50. System 50
Can be used to play interactive 3D video games with intriguing stereophonic sound. It can also be applied to various other uses.

In this example, system 50 can interactively process digital representations and three-dimensional world models in real time. The system 50 can display all or part of the world from any viewpoint. For example, system 50 can interactively change the viewpoint in response to real-time input from input devices such as handheld controllers 52a and 52b. This allows the game player to see the world as seen from inside or outside the world. The system 50 can also be used for applications that do not require real-time 3D interactive display (eg, 2D display generation and / or non-interactive display), but the ability to display high quality 3D images very quickly. It can be used to create visual interactions such as realistic gameplay.

To play an application such as a video game using the system 50, the user first connects the main unit 54 to a user's display such as a color television 56 using a cable 58. The main unit 54 generates a video signal and an audio signal for controlling the color television 56. The video signal is
This controls the image displayed on the television screen 59, and the audio signal is reproduced as sound via the stereo speakers 61L and 61R of the television.

Further, the user needs to connect the main unit 54 to a power source. This power source may be a conventional AC adapter (not shown) that plugs into an electrical outlet on the wall of the home,
4 to a lower DC voltage signal suitable for powering 4. In another embodiment, a battery can be used.

The user may control the main unit 54 using the hand controllers 52a and 52b. For example, using the operation unit 60, it is possible to specify a direction (up or down, left or right, near or far) in which the character displayed on the television 56 should move in the three-dimensional world. The operation unit 60 also provides inputs for other uses (for example, menu selection, pointer / cursor control, etc.). The controller 52 can take various forms. In this example, each of the illustrated controllers 52
Includes an operation unit 60 such as a joystick, a push button, and / or a direction switch. Controller 52
May be connected to the main unit 54 by a cable or wirelessly via electromagnetic waves (for example, radio waves or infrared waves).

In order to play an application such as a game, the user selects an appropriate storage medium 62 for storing an application such as a video game that he or she wants to play, and stores the storage medium in the main unit 54.
Into the slot 64 in the inside. The storage medium 62 may be, for example, a particularly encoded and / or encrypted optical and / or magnetic disk. The user operates the power switch 66 to operate the main unit 54.
May be turned on to start executing an application such as a video game based on the software stored in the storage medium 62. The user may operate the controller 52 to give an input to the main unit 54. For example, operating the operation unit 60 may start an application such as a game. By moving the other operation unit 60, the moving character can be moved in a different direction,
For example, the user's viewpoint in the world can be changed. Based on the specific software stored in the storage medium 62, various controls 60 on the controller 52
Different functions can be performed at different times.

<Example of Electronic Circuit of Entire System> FIG. 2 is a block diagram showing an example of components of the system 50. The main components include: A main processor (CPU) 110; a main memory 112; and a graphics and audio processor 114.

In this embodiment, the main processor 110
(Eg, extended IBMPowerPC750)
Receives input from the handheld controller 108 (and / or other input devices) via the graphics and audio processor 114. The main processor 110
In response to a user input interactively, a program, such as a video game, supplied from external storage medium 62 via mass storage access device 106, such as an optical disk drive, is executed. As an example, in the case of video game play, the main processor 110 can perform collision detection and moving image processing in addition to various interactive control functions.

In this example, the main processor 110
Generates 3D graphics commands and audio commands and sends them to the graphics and audio processor 114. The graphics and audio processor 114 processes these commands to generate an intriguing visual image on the display 59 or to direct intriguing stereophonic sound to a suitable sound generator such as stereo speakers 61R and 61L. Or generate it.

The video encoder 120 included in the example system 50 receives an image signal from the graphics and audio processor 114 and converts the image signal to a standard display device such as a computer monitor or a home color television 56. Convert to analog and / or digital video signals suitable for display. The audio codec (compressor / decompressor) 122 included in the system 50 compresses and decompresses the digitized audio signal and, if necessary, converts it into a digital or analog audio signal format. Is also good. The audio codec 122 receives the audio input via the buffer 124, and
It may be provided to audio processor 114 for processing (eg, mixing with other audio signals generated by the processor and / or receiving via the streaming audio output of mass storage access device 106).
The graphics and audio processor 114 of this example includes an audio memory 126 that can use audio-related information for audio tasks.
Can be stored. The graphics and audio processor 114 supplies the processed audio output signal to the audio codec 112 so that the audio output signal can be reproduced by the speakers 61L and 61R (for example, the buffer amplifier 12).
Decompression and conversion to analog signals (via 8L and 128R).

Graphics and audio processor 114
Can communicate with various additional devices within system 50. For example, a parallel digital bus 130 may be used for communication with mass storage access device 106 and / or other components. The serial peripheral bus 132 may be used for communication with various peripherals and other devices, including, for example, the following: A programmable read-only memory and / or real-time clock 134; a network interface such as a modem 136 (such as a digital network such as the Internet, capable of downloading and uploading program instructions and / or data. Such as connecting the system 50 to the communication network 138), and flash memory 140.

Another external serial bus 142 may be used for communication with devices such as additional expansion memory 144 (eg, a memory card). Connectors may be used to connect various devices to buses 130, 132, and 142.

<Example of Graphics & Audio Processor>
FIG. 3 is a block diagram of an example of the graphics and audio processor 114. As an example, graphics and audio processor 114 may be a single-chip ASIC (application-specific IC). In this example, graphics and audio processor 114 includes: A processor interface 150, a memory interface / controller 152, a 3D graphics processor 154, an audio digital signal processor (DSP) 156, an audio memory interface 158, an audio interface and mixer 160, a peripheral controller 162, and a display controller. 164.

The 3D graphics processor 154 includes:
Perform graphic processing tasks. Audio digital signal processor 156 performs audio processing tasks. The display controller 164 stores the image information in the main memory 112.
And gives it to the video encoder 120 for display on the display device 56. Audio interface & mixer 160 interfaces with audio codec 122 and also receives audio from another source (eg,
Streaming audio from mass storage access device 106, output of audio DSP 156, and audio codec 1
It is also possible to mix an external audio input received via the external input 22. Processor interface 150
Provides a data and control interface between the main processor 110 and the graphics and audio processor 114.

Memory interface 152 provides an interface for data and control between graphics and audio processor 114 and memory 112. In this example, the main processor 110 accesses the main memory 112 via the processor interface 150 and the memory interface 152 which are a part of the graphics and audio processor 114. The peripheral device controller 162 is a graphics &
It provides an interface for data and control between the audio processor 114 and the various peripherals described above. Audio memory interface 158 provides an interface with audio memory 126.

<Example of Graphics Pipeline> FIG.
Is a more detailed diagram of an example of a 3D graphics processor 154. 3D graphics processor 154
Includes, among other things, a command processor 200 and a 3D graphics pipeline 180. Main processor 110 communicates a stream of data (eg, a graphics command stream or a data list) to command processor 200. Main processor 110
Has a two-level cache 115 to minimize memory latency and also has a write gathering buffer 111 for uncached data streams for the graphics and audio processor 114.
The write gathering buffer 111 collects partial cache lines into complete cache lines, and sends this data to the graphics and audio processor 114 one cache line at a time so that the bus can be used to the maximum extent.

The command processor 200 receives the display command from the main processor 110, analyzes the display command, and acquires additional data necessary for processing from the common memory 112. Command processor 200 provides a stream of vertex commands to graphics pipeline 180 for 2D and / or 3D processing and rendering. The graphics pipeline 180 generates an image based on these commands. The generated image information is transferred to the main memory 112, and the display control unit /
It may be made accessible by the video interface unit 164, whereby the display 56
The frame buffer output of the pipeline 180 is displayed.

FIG. 5 shows the graphics processor 154.
FIG. 3 is a logic flow diagram of FIG. Main processor 110 may store graphics command stream 210, display list 212, and vertex array 214 in main memory 112, and pass pointers to command processor 200 via bus interface 150. Main processor 110 stores the graphics commands in one or more graphics first in first out (FIFO) buffers 210 allocated in main memory 110. Command processor 200 retrieves: A command stream from the main memory 112 via an on-chip FIFO memory buffer 216 that receives and buffers graphics commands and performs synchronization / flow control and load balancing; and via an on-chip call FIFO memory buffer 218 , Display list 212 from main memory 112,
And vertex attributes from the command stream and / or from the vertex array 214 in the main memory 112 via the vertex cache 220.

The command processor 200 performs a command processing operation 200a to convert the attribute type to a floating-point format, and passes the resulting complete vertex polygon data to the graphics pipeline 180 for rendering / rasterization. Programmable memory arbitration circuit 13
0 (see FIG. 4) is the graphics pipeline 18
0, the command processor 200 and the display controller / video interface 164 arbitrate access to the common main memory 112.

As shown in FIG. 4, graphics pipeline 180 may include: A conversion unit 1300, a setup / rasterizer 400, a texture unit 500, a texture environment unit 600, and a pixel engine unit 700.

The conversion unit 1300 performs various processes 300a such as 2D and 3D conversion (see FIG. 5). Converter 3
00 may include one or more matrix memories 300b that store the matrices used in the conversion process 300a. The conversion unit 1300 converts the shape input for each vertex from the object space to the screen space, converts the input texture coordinates, and calculates projected texture coordinates (300c). The conversion unit 1300 may perform polygon clipping / culling (300d). Also,
Lighting process 30 performed by conversion unit 300b
With 0e, in one embodiment, lighting calculations for eight independent lights are performed for each vertex. Also,
The conversion unit 1300 can also perform texture coordinate generation (300c) for producing an embossed bump mapping effect and polygon clipping / culling processing (300d).

The setup / rasterizer 400 includes a setup unit. The setup unit receives the vertex data from the conversion unit 300 and sets the triangle setup information to 1
The data is transmitted to the above-described rasterizer (400b) to perform edge rasterization, texture coordinate rasterization, and color rasterization.

The texture section 500 (which may include an on-chip texture memory (TMEM) 502) performs various tasks related to texturing. Tasks include, for example: Retrieve texture 504 from main memory 112; eg multi-texture processing, post-cache texture extension, texture filtering, embossing,
Shadow and lighting using projected textures,
Texture processing (500a), including BLIT with alpha transparency and depth; bump mapping (pseudo-texture), bump map processing (500b) to calculate texture coordinate transformations for texture tiling effects; and indirect texture. Processing (500c).

The texture section 500 outputs the transmitted texture value to the texture environment section 600 and performs texture environment processing (600a).

The texture section 500 can recycle and perform both direct and indirect texturing, and during a single rendering pass, render the texture mapping output sequence to the texture environment section 600 for blending.
Give to. U.S. patent application Ser. No. 09 / 722,382, entitled "Methods and Apparatus for Processing Direct and Indirect Textures in Graphics Systems" (Attorney Docket No. 723-961) and corresponding provisional application filed Aug. 23, 2000 See 60 / 226,891.
Both applications are incorporated herein by reference.

The texture environment section 600 blends polygons with texture color / alpha / depth and performs texture fog processing (600b) to achieve a fog effect based on the inverse range. The texture environment 600 provides a number of stages to provide various other intriguing environment-related based on, for example, color / alpha modulation, embossing, detail texturing, texture swapping, clamping, and depth blending. Function can be performed.

The pixel engine 700 has a depth (z)
Compare (700a) and pixel blending (70
0b). In this example, the pixel engine 700
Is a built-in (on-chip) frame buffer memory 7
02 is stored. Graphics pipeline 180 may include one or more embedded DRAM memories 702 to store the contents of frame buffers and / or texture information locally. Depending on the currently active rendering mode, the Z comparison 700a 'may be performed early in the graphics pipeline (eg, if alpha blending is not required, the z comparison may be performed early). The pixel engine 700 includes a copy process 700c.
This periodically writes the contents of the on-chip frame buffer to the main memory and makes the display / video interface unit 164 accessible. Using the copy processing 700c, the contents from the contents of the embedded frame buffer 702 to the texture can be copied to the main memory 112, and a dynamic texture synthesizing effect can be obtained. Anti-aliasing and other filtering can be performed during the copy-out process. The frame buffer output of the graphics pipeline 180 (finally stored in the main memory 112) is read by the display / video interface unit 164 for each frame. The display controller / video interface 164 gives the digital RGB pixel values and displays them on the display 102. The copy-out pipeline may be part of the pixel engine 700, and may allow some or all of the contents of the embedded frame buffer 702 to be used as a texture in a single rendering pass, as a texture. It can be copied out to the memory 112. Then, the texture unit 500 may read the copied-out texture into the texture memory 502 and use this as the content of the frame buffer when performing additional visualization of the texture mapping.
The system 50 can also copy out the rendered alpha information, for example, in the embedded frame buffer 702, apply this alpha information as a texture during texture mapping, and add it to the embedded frame buffer content. is there. All this takes place in the same rendering pass. U.S. patent application Ser. No. 09 / 722,663, entitled "Graphics System with Copy-Out Conversion Between Internal Frame Buffer and Main Memory" (Attorney Docket No. 723-96)
3) and its corresponding provisional application no. 60 / 227,030 filed Aug. 23, 2000. Both applications are incorporated herein by reference.

<Logical Combination of N Alpha Comparisons> Co-pending Application Serial No. 09 / 722,367, Drebin et al., "Recirculating Shade Tree Blender for Graphics Systems"
As described in (Attorney Reference No. 723-968) (all disclosures, including the drawings by this application, are incorporated herein by reference), a recirculating shader embodiment 602 (see FIGS. 6-12b). ) Correspond to various alpha functions, including the logical combination of alpha test results within a single rendering pass. In this embodiment,
The alpha function uses one of the following operations,
Compare source alpha to reference alpha. • Never • Never • Inequal • Equal • Less than • Less than • Less than • In this example, the two functions are combined using: • AND • OR • XOR • XNOR If all valid pixels in the pixel quad fail the alpha test, the quad is discarded,
Therefore, the frame buffer 702 is not updated.
In this embodiment, (part of the recirculation logic)
Note that despite the alpha channel comparison being performed using comparator 674, the alpha comparison operation is not part of the recirculation stage, but rather is performed after recirculation is complete. The following are examples that can be implemented. Example 1 Asrc> Aref0 AND Asrc <Aref1 Example 2 Asrc> Aref0 OR Asrc <Aref1 Example 3 Asrc> Aref OR Asrc <-Aref

Thus, the alpha feature of recirculating shader 602 (eg, in conjunction with a non-recirculating alpha comparison) can be used to provide a transparency tree similar to a shade tree. In particular, using the alpha function of recirculation shader 602, N logical alpha operations can be performed on M alpha inputs. Where N
And M can be any integer. Alpha comparison and alpha logic operations can be used to provide non-photorealistic effects such as, for example, cartoon outlining.

<Example of Cartoon Outlining Technology> FIG.
4 and 15 indicate that it is desirable to put a border or contour on the cartoon character. The cartoon character example 1300 in FIG. 14 has a border line attached to the silhouette outline 1302. The outline 1302 of the silhouette enhances the clarity of the image and produces a “cartoon outlining” effect of reproducing an image in the form of a hand-drawn comic or comic book.

FIG. 14 shows this cartoon character 1300.
Has a right hand, a wrist, and an upper arm, and shows a state in which the upper arm is bent in front of itself. The manga writer also attaches boundaries to the contours around the right hand, wrist, and upper arm, even though the pose of the character shown here is an internal contour rather than a silhouette contour. Character silhouette outline 1
FIG. 14 shows that if cartoon outlining is applied only to 302, the portion of the cartoon character 1300 may disappear or become unclear. In order to clearly distinguish hands, wrists, and upper arms (from the experience of coloring book and hand-drawn animated characters and / or comic books)
I hope these are also borderlined.

In order to make the cartoon character 1300 look as if it were handwritten, it would be useful to make the border line not only a silhouette outline but also a certain internal outline 304. The constant internal contour corresponds to an internal contour that defines the hand, wrist, and upper arm of the character that is bent in front of itself. FIG. 15 shows a character 1300 with these internal contours 304 bounded. These internal contours 3
04 is a silhouette outline if the character 1300 is extended with the arms raised, but is an internal outline in the arm direction in FIG.

One way to solve this problem is to use different I for different objects or parts of objects.
There is a way to track which pixels represent different objects or portions of objects by assigning D values and associating pixels with ID values during the rendering process. Such an identification value may be assigned by, for example, allocating bits in the frame buffer 702 that are typically used to encode alpha information. The assigned identification value may be used to determine whether to draw a boundary line at the pixel location. For example, the system may compare the identification value of a pixel with the identification value of a neighboring (eg, adjacent) pixel. If the identification values of two adjacent pixels are in a predetermined relationship, no border is drawn. If the identification values are the same, the two pixels are on the same plane and no border is drawn. If the identification values of two adjacent pixels are in another predetermined relationship, indicating that different objects or different parts of an object are overlapping, a border is drawn.

FIGS. 16 to 18 show an example. FIG.
Three object parts 1320, 1322, 1324
An object 1319 comprising FIG. 17 shows a plan view of the same object 1319. The object part 1320 is square and the object part 132
2 is a circle and the object part 1324 is a cone. The graphic designer places a boundary 330 (FIG. 1) where the cone 1324 visually intersects the square 1320.
6), but do not want to draw where the cone intersects the circle 1322 or where the circle intersects the square.

In this example, a square 1320, a circle 13
22, and the pixels within the cone 1324 are each coded using a different identification value. For example, square 1
The pixels in 320 are encoded with an identification value “1”, the pixels in circle 1322 are encoded with an identification value “2”, and the pixels in cone 1324 are encoded with an identification value “3”. . FIG. 18 shows an example of the alpha portion of the frame buffer 702 that stores encoded information. Shaded cells are adjacent alpha / ID
Indicates the cells to which border color will be applied based on the difference between the values, 2 (or more).

In the pixel post-processing phase after the alpha and color images have been rendered into the frame buffer 702, various identification values in the frame buffer are tested. For pixels with identical identification values as adjacent pixels (all such pixels are on the same plane), no border is drawn. In addition, if a pixel has an identification value that differs from the identification value of an adjacent pixel by a certain reference or reference set, a boundary line is not drawn (for example, the identification value of pixel k is less than 2 and pixel k + 1 If it is different from the identification value, no border is drawn.) However, if a pixel has an identification value that differs from the identification value of an adjacent pixel by some other criterion or set of criteria, a borderline is drawn (e.g., if the identification value of pixel k is more than one pixel If it is different from the identification value of k + 1, a boundary line may be drawn at pixel k).

FIG. 19 is a flowchart of an example of a pixel post-processing routine 1350 for drawing a boundary line. The routine 1350 includes a loop (blocks 1352-136).
2), and this loop is performed for each pixel [i] [j] in the image stored in the frame buffer 702. As described above, the image generation process is performed as part of rendering an image in a frame buffer.
An identification value may be set for each distinct portion of the object in the frame buffer bits that are normally allocated to store an alpha value. The test in routine 1350 tests these alpha (currently ID) values to determine whether to draw a border. In this example, routine 1350 retrieves the alpha (ID) value of pixel [i] [j] and extracts the neighboring pixels (i.e., pixel [i-1] [j] and pixel [i] [j-1]). Also retrieves the alpha (ID) value of (block 1352). Thereafter, the routine 1352 includes:
Perform the following calculation (at block 1354):
The difference between the alpha (ID) value of pixel [i] [j] and the alpha (ID) value of the adjacent pixel is determined. diffX = ABS (Alpha [i] [j] -Alp
ha [i-1] [j] diffX = ABS (Alpha [i] [j] -Alp
ha [i] [j-1]

Thereafter, the routine 1350 tests the difference values diffX and diffY obtained as a result of the calculation, and one of them exceeds a predetermined difference (for example, an arbitrary constant threshold or a programmable threshold such as 1). It is determined whether or not (block 1356). If at least one of the difference values exceeds a predetermined difference, the routine 13
50 sets the color of pixel [i] [j] to the border color (block 1358). Therefore, if the slope of alpha is from -1 to +1 in this embodiment, the pixels are considered to be on the same plane. Step 135
2-1358 are repeated for each pixel in the image (blocks 1360, 1362).

As a variation on routine 1350, an object may have a special alpha identification value (eg, 0x0
0), the pixels in the object can be specified to be ignored when drawing the border (see FIG. 20). This is useful, for example, when rendering objects without borders as bitmaps (eg, for animations showing explosions).

FIG. 21 shows how the above routine 1350 can be applied to effectively draw a border on the object 1300 shown in FIGS.
In this example, different parts of object 1300 are encoded with different alpha (ID) values.
For example, the object 1300 has two arms 1311
a, 1311b and a trunk 1309. Each arm may include a hand 1313, a wrist 1310, a lower arm 1312, an elbow 1308, an upper arm 1310, and a shoulder 1317. Each of these various parts can be encoded using a different alpha ID as follows.

[Table 1]

According to the above alpha ID encoding example, the routine 1350 draws a boundary line shown by a dark line in FIG. 21, but draws a boundary line at another (dotted line) portion where the opposite portion intersects. Absent.

The above encoding is performed for the same object 130.
It can also be used to create a boundary at the intersection of the zero connections. In conventional coloring books and hand-drawn animated cartoons, such cartoons are lined with self-intersections in order to make joints more clear and to make the muscles feel more developed. In some cases. For example, FIGS. 22-24 are enlarged views of a joint 1308 (i.e., elbow) of the character 1300, which connects the upper arm 1310 of the character with the forearm 1312. Using the encoding described above, FIGS.
The joint 1308 is bent (the alpha ID of the lower arm 1310 and the upper arm 1310) so that the outer limbs 1310 and 1312 are oriented adjacent (eg, in contact) with each other, as shown in FIG. 1312 Alpha ID
A boundary line 1316 is attached to the intersection where the body parts 1310 and 1312 intersect (based on the fact that the difference is larger than 1).

<Example of Cartoon Outlining Process Performed on System 50> FIG. 25 is an example of a high-level flowchart showing how the system 50 can be used to provide cartoon outlining. And FIG.
6 is an example showing how system 50 can be configured to implement a cartoon outlining pipeline.

Referring to FIG. 25, to perform cartoon contour imaging or a similar effect, the application sets the frame buffer 702 to include an alpha channel (block 1400). US patent application Ser. No. 09 / 726,227 entitled “Graphics System with Embedded Frame Buffer with Reconfigurable Pixel Format” (Attorney Docket No. 72)
3-957) and corresponding provisional application Ser. No. 60 / 226,910 filed Aug. 23, 2000. Both applications are incorporated herein by reference. The system 50 is then controlled to draw the scene into the frame buffer 702 (block 1402). However, during this process, the object identifier that would be provided from main processor 110 as part of each vertex information is written, for example, to the alpha channel of system 50 and stored at the alpha location in frame buffer 702.

When assigning an ID to a surface, careful attention is required. The alpha channel of this embodiment is 8
Since the number of bits is limited, if there are 256 or more different objects in one scene, the ID may need to be reused. In this embodiment, only 7 bits of alpha are available. This is because the eighth bit is used as a sign bit for threshold calculation. This is not a problem if different objects having the same ID do not overlap. If a silhouette is desired at the portion where the concave objects overlap, a more complex ID and threshold system may be used. One way to do this is to assign IDs that differ by one to different parts of the same object, so that parts that will overlap have at least two total differences. Then, the threshold function only needs to create a silhouette for at least two differences. FIG. 19 above
checking ... Of course, different embodiments have different limitations, and these specific mechanisms are only examples.

A desired portion of the image is stored in the frame buffer 7.
Once rendered in 02, the pixel engine 700 is controlled to copy the alpha image in the frame buffer to a texture in an external frame buffer or other buffer (block 1404, see FIG. 14). Such a copy-out could be, for example, in the IA8 texture format. Appropriate measures are taken to ensure synchronization and memory coherence. Synchronization described in US patent application Ser. No. 09 / 726,227, entitled “Dynamic Reconstruction of Hidden Surface Processing Based on Rendering Mode” and corresponding provisional application Ser. No. 60 / 226,890 filed Aug. 23, 2000. See token technology. Both applications are incorporated herein by reference.

The alpha texture is successfully copied out of the internal frame buffer and stored in the texture memory 5.
02 (see FIG. 14), the system 50
Reconfigures graphics processor 114 to write outline colors to pixels in frame buffer 702 based on differences between adjacent pixels alpha (block 1406). See FIG. 19 above. Processing to draw such cartoon outlines may include, for example, reading pixel alpha values, modifying those alpha values, and writing back alpha again as a blend parameter. Using a pair of texture coordinates and two different texture matrices, neighboring alpha values can be looked up from the alpha texture.
One of the matrices can be set as a unit matrix, and the other can be set as a unit matrix converted. The blend test / comparison can be performed using two common alpha comparison functions in combination with a third logical operation such as OR or AND. This allows testing outside the range, not just large or small.

More specifically, the difference calculation (for example, [a
_0- a ₁ ], where a ₀ is the alpha value of a pixel and a ₁ is the alpha value of an adjacent pixel) to subtract one alpha value from the other. , The texture environment 600 can be set to write unclamped results to the output registers of the texture environment. The alpha comparison and other value comparators in the texture environment 600 can be set to detect alpha values that exceed the threshold. alpha = texture1-texture2acomp1 = alpha <-Xacomp2 = alpha> Xkillpixel = acomp1 OR acomp
2

In this embodiment, the texture environment section 6
The unclamped negative result from 00 may be converted to an alpha value by setting the most significant bit. Thus, if the alpha difference threshold is 2, the application can write the outline color for pixels whose alpha difference is greater than 1 (up to -2) and less. Here, the maximum value is equal to 255. Based on the comparison result, the texture environment unit 600 can be set to blend with the color value from the register. Main processor 110 may also set this color value register to a desired value (eg, black for a black outlining effect, blue for a blue outlining effect, etc.).

In this embodiment, the writing of the contour line can be performed in two recirculation passes of the recirculation shader in the texture environment section 600. In a first pass (block 1408), horizontal outlining is drawn into frame buffer 702. this is,
Based on texture coordinate transformation matrix multiplication performed by the transformation unit 300 which is set to move the alpha texture image vertically by one pixel (texel). In the second pass used to write the vertical outlining (block 1410), the texture matrix can be modified to move the alpha image horizontally by one pixel (texel).
A thicker outline can be drawn by moving it by more than one pixel, but if the outline is too thick, the appearance may be abnormal.

Once both the horizontal and vertical contour lines have been written to the frame buffer 702, the frame buffer is copied out and can be displayed (block 1412).

EXAMPLE The following is an example set of programming interface calls that can be used to control the system 50 to perform cartoon outlining.

[Table 2]

<GXSetTexCopySrc><Explanation> This function uses the built-in frame buffer (EF
The source parameter of B) is set to the texture image copy. This function is provided by the graphics processor (GP).
This is useful when generating textures using.

The GP copies the texture to the tile type texture specified by GXCopyTex. GP
Always copies tiles (32 bytes) so that image widths and heights that are not a multiple of the tile width are padded with undefined data in the copied image. Also, the allocated image size in main memory must be a multiple of 32 bytes. GXGetTexBufferS
See size.

<Argument> left The leftmost copy source pixel, which is a multiple of two pixels top The topmost copy source line, which is a multiple of two lines wd The copy width is two pixels Multiple ht copy height, multiple of 2 lines

<GXCopyTex><Description> This function uses the built-in frame buffer (EF).
The contents of B) are copied to the texture image buffer dest in the main memory. This function is useful when generating a texture using a graphics processor (GP). If the clear flag is GX_TRUE, the EFB is cleared to the current clear color during the copy process (see GXSetCopyClear).
The source image is described by GXSetTexCopySrc. During the copy process, the contents of the EFB are converted to a texture format. The option box to enable texture format and filters is set using GXSetTexCopyDst.

The allocated buffer is padded and X and Y texture tiles (3 tiles per tile)
2 bytes). To determine the size after padding, a function GXGetTexBufferSize is provided.

The clear flag indicates that the frame buffer should be cleared during copy processing. The frame buffer is cleared to the constant value specified by GXSetCopyClear.

<Argument> dest: Pointer to the texture image buffer in the main memory. This pointer is adjusted to 32 bytes. clear: If this flag is GX_TRUE, the frame buffer must be cleared during copying.

<GXLoadTexObjPreLoa
ded><description> This function loads the state describing the preloaded texture into one of eight hardware register sets. Before this happens, the texture object obj is GXInitTexObj
Or it must be initialized using GXInitTexObjCI. The id parameter refers to the texture state register set. Texture is GXPr
Must be pre-loaded using eLoadEntityTexture.

When loaded, the texture is loaded into the GXSet at any texture environment (Tev) stage.
It can be used using the TevOrder function.
GXInit is initially GXSetTevOrder
GX_TEXTMAP0 to GX_TEVS
GX_TEXTMAP1 to GX_TEVS
Create a single texture pipeline, such as associating with TAG1.

Here, GXLoadTexObjPre
Loaded is GXSetTexRegionCal
Do not call the function set by lBack (or GXSetTltRegionCallBac if the texture is in color index format)
Note that the function set by k is not called). This is because the area is explicitly set. However, these callback functions must know in advance all the regions to be loaded. The default callback set by GXInit assumes that there is no preloaded area.

<Argument> obj: Points to a texture object that describes a texture and its attributes. region: points to an area object that describes the area of the texture memory. id: Names the texture referenced in the texture environment (Tev) stage.

<GXInitTexObj><Description> This function is used to initialize or change the texture object of the non-color index texture. The texture object is used to describe all parameters related to the texture, such as size, format, wrap mode, filter mode, etc. It is the application's responsibility to provide memory for the texture objects. Once initialized, the texture object is associated with one of the eight active texture IDs using GXLoadTexObj.

To initialize the texture object of the color index texture, use GXInitTex
ObjCI is used.

When the mipmap flag is GX_TRUE, the texture is a mipmap, and the texture is triple-linearly interpolated. Mipmap flag is GX_F
In the case of ALSE, the texture is not a mipmap and the texture is doubly linearly interpolated. To ignore the filter mode and other mipmap controls, use GX
See InitTexObjLOD.

<Argument>

[Table 3]

<GXInitTexObjLOD> <C language specification>

[Insert 1]

<Description> This function explicitly sets the level of detail (LOD) control of a texture for a texture object. It is the responsibility of the application to provide memory for texture objects. GXInitTexObj or GXInitTe
When the texture object is initialized using xObjCI, this information is set to a default value based on the mitt map flag. This function allows the programmer to override these defaults. Note that this function is called by GXInitTexObj or GXInitTexObj for a specific texture object.
Note that it must be after XInitTexObjCI.

The LOD calculated by the graphics hardware can be biased using the load_bias parameter. This load_bias
Is added to the calculated lod and the result is min_
Clamped between lod and max_lod. bia
When s_clamp is enabled, load_bias
The effect of s decreases as the polygon becomes more perpendicular to the viewing direction. This prevents the texture in such a state from becoming too sharp, but allows an LOD bias for diagonal polygons.

<Argument>

[Table 4]

<GXInitTexPreLoadRe
gion><Description>

This function initializes a texture memory (TMEM) area object so that it can be pre-loaded. This area depends on the application.
Assigned in M and can only be used as a pre-loaded buffer. The cache area is GXIn
Must be allocated using itTexCacheRegion. For pre-assigned textures, the size of the region must match the size of the texture. Depending on the application, many area objects can be created, and some of the area objects can overlap. However, two overlapping regions cannot be active at the same time.

The maximum size of the area is 512K.

GXInit does not create an area for loading in advance. Therefore, if pre-loading is required, the application must allocate an appropriate area. Also, GXInitTexCacheRe
gion and GXSetTexRegionCall
It is necessary to create a cache area and its allocator using Back. This is because the new area may destroy the default texture memory configuration.

<Argument>

[Table 5]

<Example of Software Controlled Process for Implementing Cartoon Outlining> The following program portion can be used to control the graphics pipeline to perform the cartoon outlining effect.

[Insert 2]

<Other Interchangeable Embodiments> Some of the above-mentioned system components 50 can be implemented even if they are other than the above-mentioned home video game consoles. For example, software such as a graphics application written for the system 50 may be executed on a platform that emulates the system 50 or uses other configurations compatible therewith. If another platform can successfully emulate, mimic, and / or provide some or all of the hardware and software resources of system 50, then the other platform can execute the software successfully. Would.

As an example, the emulator is a system 5
A hardware and / or software configuration (platform) different from the hardware and / or software configuration (platform) may be provided. An emulator system may include hardware and / or software components that emulate some or all of the hardware and / or software components of the system to which application software is written. For example, the emulator system can comprise a general purpose digital computer, such as a personal computer, which executes a software emulator program that mimics the hardware and / or firmware of system 50.

Some general-purpose digital computers (for example, IBM or Macintosh personal computers and their compatibles) currently use DirectX3
Some have a 3D graphics card that provides a graphics pipeline that supports D and other standard graphics command APIs. These may also include a stereophonic sound card that provides high quality stereophonic sound based on standard sound commands. A computer with such multimedia hardware running emulator software may have sufficient performance to approximate the graphics and sound performance of system 50. The emulator software controls the hardware resources on the personal computer platform to control the processing performance, 3D graphics performance, sound performance, peripheral performance, etc. of the home video game console platform on which game programmers write game software. To imitate.

FIG. 27 shows an example of the entire emulation processing.
201, an emulator component 1303, and game software capable of executing a binary image provided on the storage medium 62. Host 1201 may be a general purpose or special purpose digital computing device, for example, a platform with sufficient computing power, such as a personal computer or a video game console. The emulator 1303 may be software and / or hardware executed on the host platform 1201 and converts information such as commands and data from the storage medium 62 in real time into a format that the host 1201 can process. can do. For example, emulator 1303 retrieves “source” binary image program instructions that system 50 intends to execute from storage medium 62 and converts the program instructions into a form that can be executed or processed by host 1201.

As an example, software has been written to execute on a platform using a particular processor, such as IBM PowerPC, and the host 1
If 201 is a personal computer using a different (eg, Intel) processor, emulator 1303 retrieves one or a sequence of binary image program instructions from storage medium 1305 and converts these program instructions to an Intel binary It is converted into an image program instruction equivalent. Also, the emulator 1303 includes the graphics sound processor 114.
Retrieve and / or generate graphics and voice commands processed by the hardware and / or software graphics and convert these commands into a format that can be processed by the voice processing resources available on host 1201. As an example, the emulator 1303 transmits these commands to the host 12.
01 into commands that can be processed by specific graphics and / or sound hardware (eg, using DirectX, OpenGL and / or sound API).

The emulator 1303 or other platform implementing the outlining process of FIG. 25 may not have a recirculating shader, but instead uses a separate shading / blending stage pipeline to implement alpha. A comparison operation may be performed. Similarly, in other embodiments, the alpha and color information need not be stored in the same buffer, but instead this information may be stored in a different frame buffer. For example, the alpha “image” giving the object ID may be stored as a map in the main memory. Post-processing need not be performed by using texturing, but may instead be performed by a general-purpose processor. The contour rendering need not be performed in two passes. In another embodiment, the horizontal and vertical contours may be rendered in the same pass.

Emulator 1 used to provide some or all of the functions of the video game system described above
303 may be provided with a graphic user interface (GUI) that simplifies or automates the selection of various options and screen modes performed using the emulator. As an example, such an emulator 1
303 may further include extended functions compared to the host platform originally targeted by the software.

FIG. 28 shows an emulation host system 1 suitable for use with the emulator 1303.
201 is shown. The system 1201 includes a processing unit 1203
And a system memory 1205. System bus 1
Reference numeral 207 denotes a processing unit 1203 from the system memory 1205.
Combine various system components, including System 1207 includes a memory bus or memory controller,
Any of several bus configurations may be used, including those using any of a variety of bus architectures, such as a peripheral bus, a local bus, and the like. The system memory 1207 is
A read only memory (ROM) 1252 and a random access memory (RAM) 1254 are included. A basic input / output system (BIOS) 1256 contains the basic routines that help transfer information between elements in the personal computer system 1201, and includes a ROM.
1252. System 1201 further includes various drives and associated computer-readable media. The hard disk drive 1209 is
Magnetic hard disk 1211 (typically fixed)
Read from and write to it. An additional (selectable) magnetic disk drive 1213 reads from and writes to a magnetic disk 1215 such as a removable "floppy". Optional disk drive 1217 is a removable optical disk 1219 such as an optional medium such as a CDROM.
, And depending on the configuration, writing to it. The hard disk drive 1209 and the optical disk drive 1217 are connected to the system bus 120 by the hard disk drive interface 1221 and the optical drive interface 1225, respectively.
7 is connected. The drive and its related computer-readable medium nonvolatilely store data for the personal computer system 1201 such as computer-readable instructions, data structures, program modules, and game programs. In other configurations, other types of computer readable media may be used, and media capable of storing data accessible by the computer (eg, magnetic cassettes, flash memory cards, digital video disks, Bernoulli cartridges) , Random access memory (RAM), read-only memory (R
OM) etc.).

Many program modules, including the emulator 1303, may be stored on the hard disk 1211, removable magnetic disk 1215, optical disk 1219, and / or ROM 1252 and / or RAM 1254 of the system memory 1205. Such program modules may include an operating system that provides graphics and sound APIs, one or more application programs, other program modules, program data, and game data. The user inputs commands and information to the keyboard 122.
7. Input to the personal computer system 1201 through input devices such as a pointing device 1229, a microphone, a joystick, a game controller, a satellite antenna, and a scanner. Such an input device can be connected to the processing unit 1203 via a serial port interface 1231 coupled to a system bus 1207, and can be a parallel port, a game port fire wire bus, or a universal serial bus ( USB or other interfaces. A display device such as a monitor 1233 is also connected to the system bus 1207 via an interface such as a video adapter 1235.

[0100] The system 1201 may also include network interface means such as a modem 1154 for establishing communication over a network 1152 such as the Internet. The modem 1154 may be internal or external, and is connected to the system bus 123 via the serial port interface 1231. Also, via the local area network 1158 (or the wide area network 1152,
The system 1201 may be connected to a remote computing device 1150 (eg, via another communication path, such as dial-up, or other communication means).
A network interface 1156 may be provided to communicate with 1). The system 1201 is
Typically, it includes other peripheral output devices, such as standard peripherals such as printers.

In one example, video adapter 1235
Includes a graphics pipeline chipset that provides high-speed 3D graphics rendering in response to 3D graphics commands issued based on standard 3D graphics application programmer interfaces, such as versions of Microsoft's DirectX 7.0. May be. The stereophonic speaker set 1237 is also connected to the system bus 1207 via a sound generation interface such as a conventional “sound card”. Such an interface provides hardware and embedded software with assistance in generating high quality stereophonic sound based on sound commands provided from the bus 1207. Such hardware capabilities allow system 1201 to provide sufficient graphics and audio speed performance to execute software stored on storage medium 62.

The contents of all of the above patents, patent applications and other documents referred to above are expressly incorporated herein by reference.

Although the present invention has been described in terms of what is presently considered to be the most realistic and optimal embodiment,
The present invention should not be construed as limited to the disclosed embodiments. For example, the purpose of the illustrated embodiment is:
Although described as providing images with cartoon outlining, the flexible alpha comparison operation described above can be used for many different image applications. Furthermore, as described above for the double alpha comparison,
The present application is not limited to just two alpha comparisons. Furthermore, although the preferred embodiment uses a recirculating shader, it is possible to use a parallel scheme with multiple alpha comparators. Therefore, it is intended that the present invention include various modifications and equivalents falling within the scope of the appended claims.

[Brief description of the drawings]

FIG. 1 is a schematic diagram of an example of an interactive computer graphics system.

FIG. 2 is a block diagram of an example of the computer graphics system of FIG.

FIG. 3 is a block diagram of an example of the graphics and audio processor shown in FIG. 2;

FIG. 4 is a block diagram of an example of the 3D graphics processor shown in FIG. 3;

FIG. 5 is an example of a logic flow diagram of the graphics and audio processor of FIG. 4;

FIG. 6 shows an example of a reusable recirculating shader.

FIG. 7 shows an example of a shading pipeline implemented using a recirculating shader.

FIG. 8 shows an example of a block diagram of a recirculation shader.

FIG. 9 shows an example of a recirculating shader input multiplier.

FIG. 10 shows an example of an operation block diagram of a recirculation shader.

FIG. 11 shows an embodiment of a recirculation shader.

FIG. 12 shows an example of a color swap function.

FIG. 13 shows an example of a color swap function.

FIG. 14 illustrates an example of a cartoon outlining technique that encodes an object ID using alpha information.

FIG. 15 illustrates an example of a cartoon outlining technique that encodes an object ID using alpha information.

FIG. 16 illustrates an example of a cartoon outlining technique that encodes an object ID using alpha information.

FIG. 17 shows an example of a cartoon outlining technique for encoding an object ID using alpha information.

FIG. 18 illustrates an example of a cartoon outlining technique that encodes an object ID using alpha information.

FIG. 19 illustrates an example of a cartoon outlining technique that encodes an object ID using alpha information.

FIG. 20 illustrates an example of a cartoon outlining technique that encodes an object ID using alpha information.

FIG. 21 illustrates an example of a cartoon outlining technique for encoding an object ID using alpha information.

FIG. 22 illustrates an example of a cartoon outlining technique that encodes an object ID using alpha information.

FIG. 23 shows an example of a cartoon outlining technique for encoding an object ID using alpha information.

FIG. 24 illustrates an example of a cartoon outlining technique for encoding an object ID using alpha information.

25 shows an example of a cartoon outlining process performed by the system 50. FIG.

FIG. 26 illustrates an example of a cartoon outlining pipeline implemented by the system 50.

FIG. 27 illustrates another alternative embodiment.

FIG. 28 illustrates another alternative embodiment.

Claims (17)

[Claims] 1. A method of generating a graphics image, comprising: (a) generating information (including alpha) representing a surface to be imaged; and (b) generating a plurality of information in the same rendering pass. Performing an alpha comparison on the alpha information to provide a corresponding plurality of alpha comparison results; (c) logically combining the plurality of alpha comparison results; and (d) at least a portion of the logical comparison. Rendering the graphics image based on a combination. 2. The method of claim 1, wherein said rendering step includes selecting whether to kill pixels based on said logical combination. 3. The method of claim 1, wherein said performing step is performed using a recirculating shader. 4. The method of claim 1, wherein said performing and logic combining steps are performed in hardware. 5. The method of claim 1, wherein the rendering step comprises selectively determining whether to blend cartoon outline colors based on the logical combination. 6. The method of claim 1, wherein steps (b) and (c) perform an absolute value function. 7. A method for performing cartoon outlining by encoding an object identifier into an alpha channel of a real-time rendering system, the method being based on hardware using a shader including an alpha channel and an alpha comparator. Improved method comprising performing multiple alpha tests in the same rendering pass to selectively write cartoon outlines to a frame buffer. 8. The method according to claim 8, wherein a ₀ is the alpha value of the pixel,
If ₁ is the alpha value of the neighboring pixels, the shader computes the absolute value of [a ₀ -a _1], The method of claim 7. 9. The method of claim 7, wherein the shader subtracts one alpha value from another and outputs an unclamped result. 10. The method of claim 7, wherein the shader operates to detect an alpha difference value that exceeds a predetermined threshold. 11. The method of claim 7, wherein the shader produces an unclamped negative result, which is converted to an alpha value with the high order bit set. 12. The method according to claim 7, wherein the shader blends a predetermined color value based on a plurality of alpha operation results. 13. The method of claim 7, wherein the shader writes a contour in a first direction in a first pass and writes a contour in a second direction in a second pass. 14. The method of claim 7, wherein the shader recirculates to implement an alpha shade tree of any complexity. 15. The method of claim 7, further comprising mapping a texture obtained from an alpha channel and using the texture to provide an alpha difference so that the shader can evaluate. The method described in. 16. A graphics system, comprising: a texture portion including a texture coordinate matrix multiplier; a shader including an alpha channel; a built-in frame buffer capable of storing an alpha image; and copying the alpha image from the frame buffer. A copy-out pipeline for making said texture portion available as text, wherein said graphics system performs multiple alpha comparisons in a single rendering pass. 17. The system of claim 16, wherein the shader logically combines the plurality of logical alpha comparisons and blends predetermined colors based on the result of the combination.