US 7834872 B2 Abstract A method and an apparatus for shading three-dimensional computer graphic images is provided. A display on which the image is to be viewed is subdivided into a plurality of rectangular areas. For each rectangular area, a list of objects in the image which may be visible is determined, and this list is used to determine how the rectangular area should be shaded for display. In deriving the list of objects, a determination of maximum and minimum values for each object in x and y directions is used, and a set of sampling points is determined from these values. If a bounding box surrounding the object covers any of the sampling points, the object is added to the object list or otherwise rejected. Also provided is a method and an apparatus for testing an edge information for each object against the sample points to determine whether or not the object falls into the rectangular area in the bounding box surrounding the object. The step of testing the edge information includes shifting the edge information by a predetermined amount based on the orientation of each edge.
Claims(6) 1. A method for culling small objects in a system for shading 3-dimensional computer graphics images comprising the steps of:
subdividing a display on which an image is to be viewed into a plurality of rectangular areas;
for each rectangular area deriving a list of objects in the image which may be visible in that rectangular area;
using the list of objects to determine how the rectangular area should be shaded for display;
characterized in that the step of deriving a list of objects comprises the step of;
determining maximum and minimum values for each object in x and y directions;
for each object in the image, determining a bounding box from the maximum and minimum values of the x and y coordinates of the object;
determining a set of pixel sampling points from the maximum and minimum values;
determining whether or not a bounding box surrounding the object covers any of the pixel sampling points;
culling the object if the bounding box misses all the pixel sampling points;
testing each sampling point against each edge of the object;
determining from the test performed whether or not the object covers any pixel sampling point; and
adding or rejecting the object from the list in dependence on the result of the determination.
2. A method according to
3. A method according to
4. An apparatus for culling small objects in a system for shading a three-dimensional computer graphics image comprising:
a display;
means for subdividing the display on which the image is to be viewed into a plurality of rectangular areas;
means for deriving for each rectangular area a list of objects in the image which may be visible in that rectangular area;
means for determining how the rectangular area should be shaded for display by using the list of objects;
characterized in that the means for deriving a list of object comprises;
means for determining maximum and minimum values for each object in x and y directions;
for each object in the image determining a bounding box from the maximum and minimum values in the x and y directions;
means for determining a set of pixel sampling points from the maximum and minimum values;
means for determining whether or not the bounding box surrounding the object covers any of the pixel sampling points; and
means for culling the object if it misses all the pixel sampling points;
means for testing each pixel sampling point against each edge of the object;
means for determining from the test performed by the testing means whether or not the object covers any sampling points; and
means for adding or rejecting the object from the list in dependence on the result of the determination.
5. An apparatus according to
6. An apparatus according to
Description This invention relates to the generation of 3D computer graphics images and describes improvements to techniques described in our British patent 2343603, and earlier related patent, GB2298111. In these systems, the 2D image plane is subdivided into preferably rectangular regions of pixels and, for each such region, a list of the objects that are ‘of interest’ to that region is compiled. These regions will be referred to as tiles. When the list for a particular tile contains all such objects, the tile can be rendered entirely. An alternative scheme, (as described in our patent application PCT/GB01/02536), allows for partial rendering whereby the list may simply contain a subset of the required objects. It is important to have cost-effective means of determining which primitives, typically triangles and line segments, should be placed in which tiles. An example is given in The process of determining which primitives belong in which tiles is called ‘binning’ or ‘tiling’. Modern 3D computer games tend to have very high polygon counts and thus a high number of primitives. During the generation of the scene, many of the primitives become too small to be sampled and thus do not affect the image. This happens as the objects which they are used to represent recede into the distance. Storing these very small primitives in tile lists is an unnecessary use of time, memory, and processing effort. In In In 3D computer graphics, it is common for triangular/convex polygonal primitives to be defined with an associated ‘winding order’ which is typically one of {Both, Clockwise, Anticlockwise}. The winding order is used as a performance optimization to eliminate some primitives prior to rendering. This optimization functions such that if, after projection, the primitive has an order of vertices that does not match its specified winding order, that primitive can be ignored. In the IEEE 754 standard, floating point numbers are represented using a sign bit value, sign, an exponent value, ex, and an ‘M’ bit mantissa value, m, which with the exception of some minor special cases which can be ignored, represents a value equal to
Similar expressions for addition and multiplication operations can be derived:
In GB2343603, a method of determining which primitives (i.e. the basic rendering components used to represent objects) are in a particular tile is presented. For each primitive (in particular, a triangle) it first determines a bounding box of candidate tiles and then attempts to eliminate a candidate tile by testing each of the edge equations against certain corner points of that tile. For each edge, only one corner of each tile needs to be tested. If the candidate is not eliminated, then the primitive is added to the tile's list. There are several inconvenient aspects with the approach described in that patent: (1) The precision of the mathematics used to perform the rejection calculations must be at least as accurate as, or at least give identical results to, that used by the rendering system when that decides which pixels a primitive covers. An example of a potential problem is shown in This may seem like a triviality, but in practice it may be more complicated. For example, floating point arithmetic may be used to perform the various inside/outside tests, and when rendering a particular tile, the coordinate system may be re-aligned so that rather than using a pixel origin that is at the top left of the image, the rendering may use a local origin, say, at the top left of the tile. Doing this reduces the cost of the hardware needed when rendering inside the tile, however, it would make it very difficult and/or more expensive to have a ‘global test’ with exactly the same accuracy that can be used for the ‘tiling’ operation. If there is any deviation in accuracy, then there is a chance that tile ‘ Even if the mathematics provides exactly the same results as that used inside the renderer, a hardware solution would require a significant amount of silicon. An alternative could be to use fixed-point mathematics, rather than floating-point, but this incurs the problem that arbitrary polygons would have to be ‘clipped’ to the valid supported mathematical range. Clipping is an expensive operation which is preferable to avoid. (2) The ‘test corner’ of the tile varies depending on the parameters of the particular edge's line/plane equation. This is an inconvenience, as it requires decisions on a tile-by-tile/edge-by-edge basis. (3) The system only supported triangles and it is useful to also apply the ‘tiling’ process to other primitive types such as ‘thick lines’ constructed from parallelograms. Of course, it is trivial to either convert a parallelogram to a pair of triangles, or even extend the method to support any convex polygon, but for the case of lines a more efficient approach is desirable. (4) The system does not attempt to address cases where ‘tiny’ primitives, e.g. those that are around the size of a pixel, are supplied to the tiling engine but don't actually get rendered. Many such primitives, such as those illustrated in Preferred embodiments of the invention presents a method of handling not only the simple case shown in We have appreciated that although it is desirable to add each (convex polygon) primitive to the minimum set of tile lists, it may be expensive to compute this minimal set and that it is certainly safe to occasionally add extra unneeded tiles, such as ‘ As a first embodiment of the invention, a method and an apparatus are presented which safely use lower precision calculations. Furthermore, the system may be tuned to trade-off accuracy, i.e. implementation cost, of the maths against the increased likelihood of additional redundant tiles. The system also has the advantage of using a uniform testing procedure for all edges/tiles. In a second embodiment of the invention, we have also appreciated that a method of directly tiling line segment primitives that takes advantage of special properties, is desirable. The method presented is cheaper than converting the primitive to an equivalent polygon or polygons. In a third embodiment, the invention provides a means of rejecting certain ‘small’ primitives that are guaranteed not to influence the image. Preferred embodiments of the invention will now be described in detail by way of examples with reference to the accompanying drawings in which: A preferred embodiment of the invention will be presented with reference to The triangle has vertices, {(x These maximums and minimums are determined at full accuracy as this is a relatively cheap operation. As an optimization, it is also possible to test for equality of the vertex positions and reject those triangles that have repeated vertex positions, as these have exactly zero area and will not contribute to the image. At this point, the invention can also reject any primitives that are trivially completely ‘off-screen’. Using the computed bounding box and primitive's coordinates, small primitive culling tests are performed, ‘ Our British patent No. 2343603 describes how the edges of a (convex polygonal) primitive can be represented as lines (or plane equations) of the form . . .
. . . where A, B, and C are coefficients that depend on the position and orientation of the particular edge and x and y are pixel coordinates. A point, (x,y), in the image plane is defined as being strictly inside a ‘clockwise’ primitive when . . .
. . . for all edges, i. Under certain circumstances (e.g. the fill rules described in the computer graphics standard, OpenGL), some edges are also included as being inside the primitive. For the purposes of tiling, where the system can afford to be conservative, all edges can be considered to be part of the primitive and so the inside test for a ‘clockwise’ primitive is relaxed to:
‘Anticlockwise’ primitives should use a test. For brevity, the document will only describe the clockwise case, as the extension to the other cases will be obvious to one skilled in the art. For a projected triangle, GB 2343603 also gives the equations for computing the coefficients for the edge test, i.e., if (x These equations are actually derived from the adjoint of a 3×3 matrix that contains just the projected coordinates of the triangle vertices. In some situations it is preferable to calculate the (projected) edges of the triangle without having to project the vertices, i.e. using the homogeneous coordinates. In that situation, the edge equations can also be computed using the corresponding adjoint matrix and, in an alternative embodiment, the tiling operation can be performed using homogeneous coordinates. For brevity, that alternative embodiment will not be presented, but the adaptation will be clear to one skilled in the art. The overview of the processing steps contained in ‘ An initial rectangular region of candidate tiles, limited to the extent of the image plane, is then determined from the extremities, ‘ As an optimization in the preferred embodiment, when the set of candidate tiles is only a single tile high and/or a single tile wide, ‘ The next step is to compute the parameters, ‘ The process continues by iterating through the candidate set of tiles, ‘ To understand the edge equation calculations performed in ‘ Each edge is computed independently and this is now described. We define the end points (in order of definition) of edge ‘i’, in original full floating-point precision, to be (x - OrientationTypes={TopLeft, TopRight, BottomLeft, BottomRight};
- OrientationTypes Mode;
- BOOL XjGTE, YjGTE;
- // Compare the coordinate values
- XjGTE:=(xj>=xi);
- yjGTE:=(yj>=yi);
- // Determine edge orientation . . .
- IF (XjGTE AND NOT YjGTE)
- {
Mode:=TopLeft; - }
- ELSE IF (XjGTE AND YjGTE)
- {
Mode:=TopRight; - }
- ELSE IF (NOT XjGTE AND YjGTE)
- {
Mode:=BottomRight; - }
- ELSE
- {
Mode:=BottomLeft; - }
The orientation of the edge determines the adjustments made to the edge equations. This involves computing ‘shift’ amounts as described in the following pseudo-code; the T - IF ((Mode==ToTopLeft) OR (Mode==ToBottomLeft))
- {
x_shift=Tx; - }
- ELSE
- {
x_shift=0; - }
- IF ((Mode==ToTopLeft) OR (Mode==ToTopRight))
- {
y_shift=Ty; - }
- ELSE
- {
y_shift=0; - }
The logic behind this shift amount is that, rather than moving test point as a function of the edge, each edge will be shifted so that the same test corner can be used for all the edges. It will shortly become apparent to one skilled in the art that it is preferable to choose tile dimensions which are exact powers of two in size, for example, 32×16, as this will result in lower cost implementations. This shift value is used to compute a new C Floating-point mathematics is used with a small number of mantissa bits, M. This will typically be between 8 and 22 bits, with the preferred embodiment using 16 bits. From inequalities 1, 2, and 3, above, it is apparent that the errors in the floating-point numbers are bounded by their magnitudes. Using these magnitudes directly is inconvenient and so the embodiment simplifies the tests by relaxing the error bounds further. Therefore, as a first step to computing a ‘safe’ edge equation, the following values, xmag It should be apparent to one skilled in the art, that this is a simple operation when applied to floating point numbers. From these values and the application of the equations 1, 2, and 3, a ‘safety margin’ value, fslop, is computed thus:
Again, this is a simple operation in the floating point involving a ‘constant’ mantissa value (derived from the ‘ Using the reduced precision mathematics, the edge equation coefficients are calculated as follows: Once these values have been computed for each edge, the system can iterate through the set of candidate tiles, ‘ The inequality test for each edge in each tile, performed in ‘
. . . where X and Y are the coordinates of the top left corner of the candidate tile, but the preferred embodiment uses the following . . .
. . . a floating-point magnitude comparison is slightly less expensive than an addition and (2) since this formulation also allows the left hand side to be held constant while iterating through a row of candidate tiles. Although floating-point arithmetic has been used in the preferred embodiment, it would also be feasible with some adjustments to employ integer calculations. Although unit ‘ In an extension to the preferred embodiment, support for wide line segments is also provided, and would re-use many of the facilities provided for the tiling of other triangle/convex primitives. These line segments are preferably of the form shown in As with the triangle primitives, the first step is to compute the bounding box of the candidate tiles. Because the preferred embodiment avoids the use of full accuracy mathematics for cost saving purposes, it is not possible to know with 100% certainty which class a particular line segment falls into. For this reason the bounding box calculation will assume that the line segment could have either horizontal or vertical ends. As before, the system can compute min and max values of the end points cheaply. For the preferred embodiment, a bounding box on the segment is set to be:
This then determines the set of the candidate tiles and steps For the testing of the edges, the present invention only needs to consider the two edges that are parallel to the central axis, as the end caps have effectively been tested as part of the bounding box. These will be called Edge0 and Edge1. The computation of Edge0's a and b values is done as before:
The computation Edge0's C co-efficient, - IF ((Mode==ToTopLeft) OR (Mode==ToBottomLeft))
- {
x_shift=(Tx+w_x/2); - }
- ELSE
- {
x_shift=(−w_x/2); - }
- IF ((Mode==ToTopLeft) OR (Mode==ToTopRight))
- {
y_shift=(Ty+w_y/2); - }
- ELSE
- {
y_shift=(−w_y/2); - }
The remainder of the calculation for
For edge1, the ‘a’ and ‘b’ values are simply negatives of Edge0's values, while its c coefficient is computed using the above procedure. We now describe the steps taken in unit ‘ The processing is described with reference to where └x┘ and ┌x┐ are the standard ‘floor’ and ‘ceiling’ operators. As examples, in In step ‘ Because it is not cost effective to consider primitives larger than a certain size, the preferred embodiment limits its small object culling tests to those primitives whose chosen sampling locations are spread out no further than a 1×1 pixel area. Step ‘ The invention now tests each of the four sampling points to see if they are inside the primitive: As before, the edge coefficients, ‘ Note that there are at most three possible cases to consider: That of only one distinct sampling point, two distinct sampling points (as shown by ‘ In the preferred embodiment, up to four sample locations can be tested, ‘ A _{i}(S _{xmin}+1)+B _{i} S _{ymin} +C _{i}≧0 A _{i} S _{xmin} +B _{i} S _{ymin} +C _{i} ≧−A _{i}
A _{i} S _{xmin} +B _{i} S _{ymax} +C _{i}≧0 A _{i} S _{xmin} +B _{i} S _{ymin} +C _{i} ≧−B _{i}
A _{i} S _{xmax} +B _{i} S _{ymax} +C _{i}≧0 A _{i} S _{xmin} +B _{i} S _{ymin} +C _{i} ≧−B _{i} −A _{i}
As can be seen, the same basic calculation is reused, i.e. A A sample point is deemed to be outside the primitive if any of the edges fails its test. In step ‘ In an alternative embodiment, a larger than 2×2 sampling grid could be used. Patent Citations
Non-Patent Citations
Referenced by
Classifications
Legal Events
Rotate |