JP4499291B2 - Shading and texturing 3D computer generated images - Google Patents

Abstract

A method and apparatus for shading and texturing 3-dimensional computer generated images deals with punch through textures by supplying data defining a group of surfaces representing each object in the image. For each elementary area of the display, a depth value is generated for each surface of each object in dependence on the distance of that surface from an image plane. Shading and texture data is applied to the surfaces. A determination is made as to whether or not any texture applied to a surface is fully opaque. The depth values are stored for opaque textures at the appropriate elementary areas. The depths of surfaces from subsequent objects are then compared with depth values for the opaque objects at elementary areas and, surfaces or subsequent objects for elementary areas which have a fully opaque surface closer to the image plane than the surface being considered are discarded.

Description

[0001]
(Technical field of the invention)
The present invention relates to a method and apparatus for shading and texturing 3D computer generated images.
[0002]
(Background of the Invention)
The standard method used for shading and texturing when generating 3D images is the z or depth buffer system. It has been used for many years and is now an industry standard.
[0003]
In our UK Patent No. 2281682 we presented an alternative method with many advantages over the z-buffer system. It is called a ray-casting technique, where each object (polygon) in an image is defined by a set of infinite surfaces tagged in the forward or reverse direction. When a ray from a certain viewpoint is poured into the scene, the intersection with the surface is determined along with the distance from the image plane to the intersection. By analyzing this data, it is possible to determine for each pixel which surface of each polygon is visible, so that shading and texturing of the pixels are possible. This method is executed by using a pipeline of processing elements, and each element performs a surface block calculation of a ray to obtain a depth value of the surface in order for each pixel. Once the depth value of a surface of a pixel is determined, using these processing elements, the depth value is stored in the depth or z-buffer with data identifying the surface. The z-buffer information is now read by the texture device and used to apply the texture data for display.
[0004]
Surfaces in the system may be opaque or translucent. In order to be able to display a translucent effect, a blend value can also be associated with the face. For example, a cloud is modeled as a translucent surface by assigning RGB values that define color and alpha blending values to define translucency. Translucency is controlled by adjusting the alpha value of the texture map across the surface. A commonly used blend mode is known as alpha blending, where successive polygons are blended into the frame buffer and put into the following equation.
[0005]
RGB (new) = alpha * RGB (frame buffer) + (1-alpha) * RGB (texture)
This technique is well known. The limitation when using alpha blending is that to render a correctly blended image, the pixels that display the polygons are rendered from back to front in depth order so that each contributes an exact amount to the final image. And must be presented to the blending unit. In the case of a z-buffer system, this ordering is usually performed by the application software that supplies the z-buffer. This is referred to as a presort mode. Ray casting techniques can use either a presort mode or an automatic pixel precision sort.
[0006]
There is a special case of translucent texture called “punchthrough”. This is defined as a translucent texture where the alpha component is limited to either “on” or completely transparent or “off” or completely opaque. This type of texture can be modeled first with a complex scene like a forest using a relatively small number of polygons, and secondly with a traditional z-buffer punch-through regardless of the order in which the polygons are presented to the system. It is very popular in 3D game applications for the above two reasons that translucency can be rendered accurately.
[0007]
A traditional z-buffer pipeline with an alpha test for translucency is shown in FIG. Here, the rendered polygon is first subjected to scan line conversion in the polygon scan converter 2, and the resulting x, y, z, u, v, and w values are then converted to the texturing unit and depth test. Sent to the unit (z-buffer). The texture address is sent to the texture memory. The texture values retrieved from the texture memory are passed to the texture filter 4 which reduces aliasing artifacts due to the texture resampling process. The filtered value is sent to the texture blend unit 6 where the base color and highlight of the polygon are blended with the texture value. Next, in alpha test unit 8, an alpha test is performed on the alpha component of the resulting pixel. This test is by comparison with a reference alpha value.
[0008]
The alpha test unit performs a size comparison with respect to the alpha reference value. A comparison mode in which the user is one of the alpha reference values and is not possible, less than, equal to, less than, greater than, not equal, greater than, or always give. The test selected depends on the type of image the user is creating. The alpha test unit outputs whether the input alpha value passed or failed the comparison mode.
[0009]
If the alpha test result passes, then a depth test is performed on the updated z-buffer z and RGB values. If the test fails, the pixel is not processed further. Thus, in the typical case where the reference alpha is 1 and the test is “greater than or equal to”, only opaque pixels are written to the frame buffer, and these pixels are the other polygons in the scene, regardless of the order in which the polygons were processed. A depth comparison test will be performed for all. The depth test is performed by the depth test unit 10, which can read the z value from the z buffer 12 via the stencil unit 14 and write the z value directly to the z buffer storage. The depth test conditions are shown next to the depth test unit in FIG.
[0010]
FIG. 2 illustrates our UK Patent No. 2281682 ray casting approach using deferred texturing, a method in which texturing data is applied at the end of the ray / surface intersection test process. The apparatus includes a polygon setup unit that provides data defining the plane equations of the polygon. This data is then sent to an array 22 of processing elements so that one ray / surface intersection test can be performed for each processing element to generate a depth value for that ray / surface intersection. Typically, a processing array operates on a subset of all images known as, for example, 32 × 32 pixel “tiles” and operates on one polygon at a time. The calculated depth value is stored in the tile depth storage device 24.
[0011]
The depth values and surface values from the tile depth store are sent to the parallel run length encoder 26. This encoder provides an output to the texturing unit via the XY address for the pixel sent to the polygon scan conversion unit 28 and the tag going to the polygon setup unit 30. This encoder calculates the plane equations for texturing and shading and recalculates the polygon plane equations.
This setup unit receives the polygon texture data and provides the data to the polygon scan conversion unit 28. The RGB and alpha values and highlights applied to a surface are then sent to the texture blending unit 32, where they are passed through the filter 34 to the RGB and alpha values from the texture memory. After being combined and then passed to the tile accumulation buffer, it will be sent to the main frame for the image from there.
[0012]
The advantage of deferring texturing until all ray / surface intersections have been performed is that texture and shading operations are only performed on visible pixels. Thus, the effective fill rate is increased by the ratio of blocked pixels to visible pixels in the scene. Of course, in the deferred texturing pipeline, depth testing is done before texturing occurs, that is, before alpha testing. As a result, punch-through textured polygons are accurate unless they are presented non-overlapping in back-to-front order, or are subject to pixel precision presorting operations earlier in the pipeline. It is impossible to render. In order to realize such an arrangement, first, an unnecessary restriction is imposed on the software driver. Second, unnecessary processing overhead is required.
[0013]
We overcome this problem by including a feedback loop from the alpha test results for each pixel to the depth store, and by deferring the update of the depth store until the alpha test results for each pixel are known I thought it was possible. This requires both feedback from the alpha test to the depth test and a feedforward from the depth test unit to the alpha blending unit.
[0014]
Using this idea, there are four standard operating modes:
1. Standard z-buffer, unsorted punch-through compatible mode,
2. No sort, enhanced punch through mode with deferred operation,
3. Enhanced punch through mode with automatic surface sorting and deferred operation,
4). Generalized automatic sort, alpha blend mode,
Can be used.
[0015]
These modes of operation and preferred embodiments of the present invention will now be described by way of example with reference to the accompanying drawings.
[0016]
The block diagram of FIG. 3 is a modification of FIG. 2 according to an embodiment of the present invention.
[0017]
As shown in FIG. 2, the polygon setup block 20 receives polygon vertex data before sending the polygon surface data to the processor element array 22 which calculates the depth of each face for each pixel and stores them. This also includes a depth tester that determines the surface closest to the image plane for each pixel. This can provide the standard ABC and tag data used to define each surface to the bypass FIFO storage 40. The FIFO storage device 40, in turn, is configured to send the parameters back to the processor element array 22 when controlled.
[0018]
The XY address data and tag data are sent by the parallel run length encoder 26 to the polygon setup unit 30 and the polygon scan converter 28 in the same manner as in FIG. The polygon setup unit receives polygon texture data from the texture store. Blending unit 32 and filter 34 operate in the same manner as shown in FIG. However, an alpha test unit 42 is provided after the texture blending unit. It has a pass / fail result output that is used as a control for a punch-through control block 44 that also receives alpha values and position data from the alpha test unit. The alpha test unit has an output to the conditional blend unit 46 which does not send the textured data directly from the tile depth store 24 before sending it to the tile accumulation buffer 36. Blend with.
[0019]
For surface data, there is also an automatic sorting unit connected to the tile depth storage. This sends the data to the vertex requester 50, which now ensures that the polygon vertex data is supplied to the polygon setup unit 20 in the proper order.
[0020]
It has a sort direction control to allow the surface to be sorted from front to back and back to front and a bypass control that prohibits its use. The use of the circuit will be described for each of the four modes.
[0021]
The z-buffer is such a widely used rendering algorithm, and it is useful to have a mode of operation that emulates it, as it is generally familiar to many programs. In this way, the advantages of the ray casting rendering algorithm can be enjoyed while appearing to operate in the z-buffer mode.
[0022]
In this mode, the polygon bypasses the automatic sort logic 48 when a control signal is sent to the bypass input. Instead, the polygons are not sorted and are passed to a depth test unit that cooperates with the tile depth store 24. At this point, instead of depth calculations being performed, the standard ABC and tag parameters that form the basis of the ray-casting technique are stored in the bypass FIFO 40, and the screen XY position and tag values are in turn deferred texture by surface. Sent to the ring unit.
[0023]
In this mode of operation, all pixels are presented to the texture unit regardless of whether they have been covered by previously rendered opaque pixels closer to the current pixel's viewpoint, Texturing is not postponed. The texture unit processes “texels” (texture elements) in the order in which they are presented. The texel is filtered, blended with the base colors and highlights of the polygon, and alpha tested in the same way as with a conventional z-buffer (see FIG. 1). For each pixel, if the alpha test passes, the corresponding depth is calculated from the ABC and tag parameters stored in the FIFO 40 and fed back to the processor element array 22 and then placed in the tile depth store 24. This corresponding depth is then calculated in the associated depth test unit and the tile depth store is updated. The pixel RGB values are now blended by the conditional alpha blend unit 46 into the tile accumulation buffer. This process continues until all polygons in the scene have been processed. The speed of this operation is equal to the speed of a standard z-buffer since all polygons must be textured and shaded. Simply texturing and shading visible polygons does not save anything.
[0024]
The second mode of operation is a mode in which punch-through control is used to accelerate processing, but there is no polygon and surface data sorting prior to shading and texturing. This mode is the same as that described for the z-buffer operation, except that the polygon is depth tested against the current content of the tile depth store before being passed to the texturing unit. The punch through texture is detected by the alpha test unit 44. The unit signals the punch-through control unit 44 to send the punch-through surface back to the processor element array 22. They are then sent to the tile depth storage and depth test unit 26 where a comparative test is performed on the current content in the storage. If they are closer to the image plane, they are replaced with the current content. If a continuous polygon or part of a polygon is covered by previously rendered opaque pixels at a particular pixel, it is not sent to the texturing unit. Thus, the degree of improvement in filling speed compared to the z-buffer system depends on two factors: first, the order in which polygons are presented, and second, the latency between the depth test and the alpha test. Is done. For example, if the polygon happens to be presented from back to front and does not overlap, the filling speed is the same as the z-buffer system. On the other hand, if the polygons are presented in front-to-back order in a zero-lag system, the filling speed requirement is the ratio of ideal covered pixels in the scene to visible pixels in the scene (i.e. Depth complexity). The impact of latency in the system will lead to a reduction in the efficiency of the process. The reason is that for a finite time window (the amount of latency in the system), a percentage of pixels that could be identified as being covered by a zero latency system are passed to the texturing unit to reduce the texturing bandwidth. It is because it will consume. This latency is inherent because it takes time to texture the first polygon and do alpha and depth tests through the texturing unit. Once this initial latency is overcome, the processor element unit and tile depth store and depth test unit 24 are provided with the new polygon depth, and as a result of the alpha test, the pixel in question is in the scene. If it is known that it is a punchthrough pixel covering another pixel, a depth test is performed on the previously rendered polygon.
[0025]
The third mode of operation is a deferred texturing pipeline process that uses a translucent sorting algorithm.
[0026]
As described above, the degree of filling speed improvement according to the present invention varies depending on the order in which polygons are presented. An advantage gained by using punchthrough control in combination with pixel precision automatic sorting is that the system can ensure that polygons and portions of polygons are always processed in an optimal order. The punch-through processing automatic sorting algorithm differs from the alpha blending processing algorithm in two main ways. First, punch-through pixels are sorted from front to back, not back to front. This is because if there is punchthrough, its alpha value is 1, and none of the subsequent surfaces contribute to the shade and texture applied to the pixel. Second, the sort overhead can be reduced by breaking the sort list into smaller chunks. We call this “chunking”.
[0027]
The operation of the punch-through automatic sort algorithm will be described with reference to FIG. This represents the portion that performs the ray casting algorithm in FIGS. 2 and 3, but the texture hardware is not shown.
[0028]
As can be seen, the cache memory 52 is provided between the polygon setup unit 20 and the processing element array 22. Tile depth storage and depth test unit 24 has an output to autosort logic 56 that is coupled to autodiscard logic 58 and chunking logic 54. The chunking logic 54 also has an output back to the cache 52 and an output sent to the vertex requester unit 50. Autosort logic 56 includes at least one additional tile depth storage in preparation for temporary storage of data. When searching for an opaque surface, these are not necessary as it can be determined whether an opaque pixel is closer than the current depth compared to the currently stored depth. These are used when sorting translucent objects. These additional depth storage devices may be provided in the tile depth storage device and depth test unit 24.
[0029]
Punchthrough textures are typically used to model complex structures such as forest and cloud scenes, so the number of polygons used for punchthrough is used when alpha blended translucent. Much more than the number of polygons being played. Inevitably, the processing overhead for sorting must be minimized in order to increase system efficiency. Even a simple algorithm for sorting n objects in upward or downward order is n ² Requires operations. This is illustrated in FIG. 5, where a wood punch-through texture is seen on the front, where the wood portion is opaque texels and the surroundings are transparent texels. Automatic sorting is performed by sequentially rendering all of the translucent polygons to identify the bottom layer. Thus, the number of polygons per tile processed is the number of polygons multiplied by the number of layers, 2n ² It becomes.
[0030]
If each selected object is discarded by the sorting operation, the number of operations is
n + n-1 + n-2 +. . . . . . . . +1
And approximately n ² Equal to / 2. A characteristic of punch-through sorting is that sorting can be chunked without causing visual errors. For chunking, the number of operations is MOD (n / m) ^* m ² + REM (n / m) ² Where n is the chunk size. Reducing the chunk size leads to a decrease in both sorting overhead and sorting efficiency. Regardless of how this algorithm is actually implemented, there is a trade-off between computing resources that can be used for the sort algorithm and punch-through operations. The advantage of chunking is that it gives you more freedom to explore this trade-off. The sorting algorithm can be further optimized as long as it cannot be terminated at an early stage when all the pixels in the tile have been examined for validity (ie, assigned a valid opacity depth). This is illustrated in FIG. In tile (a), the nearest polygon hides all subsequent polygons. Therefore, the number of polygons to be processed is n.
[0031]
In one pass of the punch-through sorting algorithm, the closest polygon to the image plane is found for each pixel. In the case of tile (a), it can be determined that the nearest opaque polygon is found for each pixel in the tile in the first pass, and therefore no further passes are necessary.
[0032]
Polygon data chunks are provided by chunking logic 54 to tile depth storage, depth test logic, and autosort logic. They then pass polygons that are no longer needed to the discard logic.
[0033]
The autosort logic then sorts the rendered polygons in the direction controlled by the sort direction input and sends them to the cache memory 52, from which the polygons are again sent to the processor element array 22 for the final In effect, it will be sent to the texturing unit. In this way, the autosort logic sorts the polygons and places them in front-to-back order, so when used in the device of FIG. 3, the closest fully opaque pixel is processed first, followed by Since polygons need not be textured, the processing overhead of complex scenes can be significantly reduced.
[0034]
The fourth mode of operation of the circuit of FIG. 3 is a generalized autosort alpha blend mode.
In modern graphics controllers that perform bilinear and trilinear texturing as standard operations, the uneven visibility characteristics of punch-through textures are becoming increasingly unacceptable. A typical artwork, such as a wood texture, will have the stem portion punched through (ie, fully opaque) and the leaf tip alpha blended (ie, partially translucent). . Using the circuit of FIG. 3, such types of alpha blended textures can be accurately rendered while retaining the benefits of deferred texturing.
[0035]
To do this, two passes will be performed on the tree surface data. In the first pass, the punch-through portion of each polygon in the tile is processed as described in the automatic sort mode. Since the alpha test unit 42 is set to pass only completely opaque texels, at the end of the pass, the tile depth buffer is fully opaque to the eye closest to the eye for each pixel location in the tile. Possesses deep texel depth. In the second pass, the autosort algorithm sorts the pixels from the back to the front, and for each visible polygon fraction, only non-opaque (ie alpha blended leaf edges in the tree example) is textured. Depth test is set to “greater than” to prevent proceeding to the unit. The second pass sorts from back to front so that all partially overlapping translucent textures are blended correctly. The second pass is very efficient because in a typical scene (ie punch-through forest) only a small percentage of the total pixels in the polygon list pass the depth test. The suitability of this technique for general alpha blended textures depends on the ratio of opaque texels to translucent texels in the texture map. In the tree example, the algorithm is optimal. However, if all the textures are clouds and there are no opaque pixels, then standard automatic sorting is the preferred method.
[0036]
From the above description, the present method and apparatus operating with ray casting techniques for rendering 3D images has been modified to enjoy the benefits of reducing the processing overhead due to punch-through textures and the operation of the system. It will be understood that this can lead to speedup. The use of punch-through textures is particularly beneficial in scenes where there are many overlapping punch-through textures such as cloud scenes or forests. Using punch-through processing means that only the polygon closest to the viewpoint for each pixel can be given a texture value. Without this operation, it would be necessary to apply a texture to all polygons that block rays that pass through the pixel. Thus, in a forest-like scene, there is no doubt that thousands of texturing operations are required for each pixel rather than one pixel. This is why very complex scenes can be textured at a much faster rate than other methods.
[Brief description of the drawings]
FIG. 1 shows a z-buffer system according to the prior art.
FIG. 2 shows a prior art ray casting system using deferred texturing.
FIG. 3 is a diagram showing a preferred embodiment of the present invention.
FIG. 4 shows another preferred embodiment of the present invention with an automatic sorting unit.
FIG. 5 is a schematic diagram showing an automatic sorting method for polygons.
FIG. 6 is a schematic diagram showing still another automatic sorting method for polygons.

Claims (8)

In a method for shading and texturing a three-dimensional computer generated image,
Providing in turn data defining a group of surfaces representing each object in the image;
For each basic area of the display, generating a depth value for each surface of each object according to the distance of the surface from the image plane;
Determining whether the surface in the base area is completely opaque;
Storing a depth value for the opaque surface of the object in the base area in a depth test means;
Comparing the depth of the surface from the subsequent object to the depth value of the opaque object in the base area;
Discarding the surface of the subsequent object for the basic area that already has a completely opaque surface that is closer to the image plane;
Applying shading and texture data to the surface determined to be visible in each elementary area;
A method characterized by comprising.   The method of claim 1, wherein objects in the image are first sorted from front to back such that a completely opaque object prohibits texturing of objects behind it.   At least one texture contains a completely opaque part and a translucent part, the objects in the image are first sorted from front to back, and the texture of the object behind it using a completely opaque element The method of claim 1, wherein ringing is prohibited, and then the objects are sorted from back to front so that texturing is applied to non-opaque elementary areas. 4. A method as claimed in any preceding claim , comprising a set comprising initially dividing the image into a plurality of rectangular areas and shading and texturing each rectangular area in turn. In an apparatus for shading and texturing a 3D computer generated image,
Means for sequentially providing data defining a group of surfaces representing each object in the image;
Means for generating a depth value for each surface of each object in each basic area of the display according to the distance of the surface from the image plane;
Means for determining whether the surface in the basic area is completely opaque;
Means for storing the depth values in the depth test means for the opaque surface of the object of the prime area,
Means for comparing the depth of the surface from the subsequent object to the depth value of the opaque object in each base area;
Means for discarding the surface of the subsequent object for a base area that already has a completely opaque surface that is closer to the image plane;
Means for applying shading and texture data to the surface determined to be visible in each elementary area;
A device characterized by comprising:   6. A means for sorting objects in an image from front to back so that a completely opaque object prohibits texturing of objects behind it. apparatus. At least one texture contains a completely opaque part and a translucent part. First, the object in the image is set so that a completely opaque element is used to prohibit texturing the object behind it. 6. A means for sorting objects from back to front so that they are sorted from front to back and then texturing is applied to non-opaque elementary areas. the method of.   8. A method according to any of claims 5, 6 or 7 including means for initially dividing the image into a plurality of rectangular tiles.

Images