US20100271370A1 - Method for distributed clipping outside of view volume - Google Patents
Method for distributed clipping outside of view volume Download PDFInfo
- Publication number
- US20100271370A1 US20100271370A1 US12/783,433 US78343310A US2010271370A1 US 20100271370 A1 US20100271370 A1 US 20100271370A1 US 78343310 A US78343310 A US 78343310A US 2010271370 A1 US2010271370 A1 US 2010271370A1
- Authority
- US
- United States
- Prior art keywords
- clipping
- valid
- primitive
- triangle
- module
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Abandoned
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06T—IMAGE DATA PROCESSING OR GENERATION, IN GENERAL
- G06T15/00—3D [Three Dimensional] image rendering
- G06T15/10—Geometric effects
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06T—IMAGE DATA PROCESSING OR GENERATION, IN GENERAL
- G06T15/00—3D [Three Dimensional] image rendering
- G06T15/10—Geometric effects
- G06T15/30—Clipping
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06T—IMAGE DATA PROCESSING OR GENERATION, IN GENERAL
- G06T17/00—Three dimensional [3D] modelling, e.g. data description of 3D objects
Definitions
- the invention relates generally to the field of computer systems and more particularly to 3D computer graphics processor.
- the view frustum is the region of a three dimensional space in the modeled world that may appear on a computer display screen represented by the 2D screen space (hereinafter also referred to as the screen space).
- the exact shape of the view frustum may vary, e.g. it may be a rectangular cube, a rectangular pyramid, or other suitable geometric shape.
- the frustum may be formed with six planes: near plane, far plane, +X plane, ⁇ X plane, +Y plane, and ⁇ Y plane.
- the planes that cut the view frustum perpendicular to the viewing direction are called the near plane and the far plane, which may also be called the near Z plane and the far Z plane.
- 3D objects in the view frustum may be represented by multiple geometric primitives, such as polygons, triangles, line segments, points, or other appropriate geometric elements. Geometric primitives that fall outside of the view frustum will not be visible and may be discarded, removed, or abandoned, in view frustum clipping, or culling, operation of the graphics processing pipeline.
- culling refers to the complete removal of a geometric primitive which is completely outside of the view frustum
- clipping refers to the partial removal of a geometric primitive which has a partial portion outside of the view frustum. Culling may be considered as a special case of clipping where the partial portion removed defaults to the complete geometric primitive.
- Graphics processing pipeline typically includes a primitive assembly module (hereinafter referred to as the PA module) where 3D objects, which may be represented by multiple vertices computed from a vertex shader module, are converted to geometric primitives such as triangles, lines, points, polygons, or other appropriate geometric elements. For example, lines may be drawn from a starting-point (or starting-vertex) to an ending-point (or an ending-vertex) in order to pass conformance tests.
- PA module primitive assembly module
- 3D objects which may be represented by multiple vertices computed from a vertex shader module, are converted to geometric primitives such as triangles, lines, points, polygons, or other appropriate geometric elements. For example, lines may be drawn from a starting-point (or starting-vertex) to an ending-point (or an ending-vertex) in order to pass conformance tests.
- PA module may also perform a conversion from the view frustum to the 2D screen space.
- the X and Y coordinates are transformed into screen space, while the per-pixel Z values may be stored in a Z-buffer.
- the primitives are in the screen space. The rest of the pipe acts only on the screen space.
- a clipping block may be added behind a primitive assembly block and before the SE module.
- the primitive assembly block would just assemble the primitives
- the clipper block would clip the primitives and generate more primitives based on this clipping and than pass it on to a transformation pipe which transforms the clipped primitives to the screen space before it enters the SE module.
- This whole pipe including the primitive assembly block, clipper block, and the transformation pipe is called the PA module.
- Graphics processing pipelines typically also include a rasterization module (hereinafter referred to as the RA module) where all the pixels in a clipping window inside the 2D screen space are rendered.
- the RA module operates on the clipping window which may be a portion of the view frustum.
- Pixels in the screen space outside of the clipping window also need to be clipped/culled, i.e., discarded, removed, or abandoned.
- additional set up functions e.g., computing an initial point of rasterization for a primitive
- SE module set up module
- clipping/culling of 3D objects outside of the view frustum is typically done in a single place inside a graphics processing pipeline. Such an implementation can cause a bottleneck in the pipeline because of the large number of computation required for performing clipping/culling.
- view frustum clipping/culling may be done in the screen space.
- all the 3D objects are transformed to screen space and sent to the setup engine to do the clipping according to the clipping window.
- the advantage of this approach is that the hardware in the PA module may be very simple.
- all the 3D objects need to be transformed to screen space, even the objects outside of view frustum or clipping window. This may increase complexity and cost of the graphics processing pipeline implementation.
- all 6-plane clipping may be done in the view frustum before the conversion to the 2D screen space.
- the advantage of this approach is that all polygons outside of the view frustum are clipped; only the polygons inside the view frustum are transformed to screen space and sent to setup engine.
- the disadvantage of this approach is that the algorithm of doing 6 plane clipping is complex and expensive for hardware implementation.
- the present invention involves a method for clipping in a 3D computer graphics processing pipeline
- the 3D computer graphics processing pipeline comprises a view frustum, a clipping window, a primitive assembly (PA) module, a set up (SE) module, and a rasterization (RA) module
- the method comprising: obtaining a primitive using the PA module; performing a first clipping of the primitive using the PA module; determining an initial point of rasterization for the primitive using the SE module; performing a second clipping of the primitive using the SE module; rendering the primitive using the RA module; and performing a third clipping of the primitive using the RA module.
- FIG. 1 is a flow chart diagram illustrating an overall clipping/culling procedure of a graphics processing pipeline according to one embodiment of the present invention.
- FIG. 2 is a flow chart diagram illustrating clipping/culling procedure in the PA module of the graphics processing pipeline according to one embodiment of the present invention.
- FIG. 3 is a flow chart diagram illustrating clipping/culling procedure in the SE module of the graphics processing pipeline according to one embodiment of the present invention.
- FIG. 1 is a flow chart diagram illustrating an overall clipping/culling procedure of the graphics processing pipeline according to one embodiment of the present invention.
- the graphics processing pipeline includes the PA module, the SE module and the RA module.
- step 102 receives multiple vertices representing 3D objects.
- the vertices may be received from a vertex shader module which computes these vertices for representing 3D objects.
- Step 104 converts these 3D objects from vertices to geometric primitives, such as points, line segments (hereafter referred to as lines), triangles, or other appropriate geometric shapes.
- the PA module is configured in a triangle mode. In triangle mode, the vertices are converted into multiple triangles before any further processing.
- the PA module is configured in a line mode and converts the vertices into multiple lines before any further processing.
- the PA module is configured in point mode and converts the vertices into multiple points before any further processing.
- the points may be associated with a position attribute and a size attribute that may be used in rendering steps later in the graphics processing pipeline.
- the +X, ⁇ X, +Y and ⁇ Y planes form a X, Y clipping rectangle of the view frustum.
- the algorithm includes:
- the near Z clipping may be performed by various methods known to one skilled in the art of 3D computer graphics. What is an important aspect of the present invention is that not all steps of view frustum clipping/culling are performed in one single location in the graphics processing pipeline.
- the coordinates of primitives may be transformed to screen space in step 106 , and sent to the SE module and the RA module to perform the rest of the clipping.
- the SE module determines the initial point of rasterization which must be inside the clipping window. Additional clipping/culling may be performed during this determination process.
- the clipping window resides in the screen space.
- the SE module starts with the vertices of a triangle or a line inside the clipping window as the initial point of rasterization. If none of the vertices are inside the clipping window, it computes the initial point of rasterization as a point which is both inside clipping window and inside the triangle or part of the line.
- the SE module may compute the intersection of the line and the clipping window as the initial point of rasterization. If no such intersection can be found, the line is culled.
- each point as a geometric primitive may be converted to a polygon with appropriate size according to the associated size attribute in the SE module. The polygon may be further converted as one or more triangles.
- the SE module implements the trivial rejection for the points after the polygon conversion. In an example, points are trivially rejected inside the PA module and the SE only culls if the entire primitive is outside the clipping window or beyond the far Z plane.
- the SE module performs trivial rejection (culling) if it cannot find any intersection with the clipping window or the primitive is beyond the far Z plane.
- SE module may perform the trivial rejection to all geometric primitives including the triangles and lines for ease of implementation without having to differentiate between the modes in which the PA module is configured or to differentiate between geometric primitives.
- the trivial rejection is performed by way of computing the initial point of rasterization inside the clipping window.
- One skilled in the art will appreciate that the invention may be practice with SE module performing the trivial rejection either including or excluding the other geometric primitives.
- the RA module performs per-tile, per-subtile, per-quad, and per-pixel clipping.
- Rasterization in the RA module may be implemented in various manners known to one skilled in the art of 3D computer graphics.
- the rasterization may be implemented in a hierarchical approach, such described in U.S. patent application Ser. No. 11/592,799 (Docket No. GIQUILA-P001), filed on Nov. 3, 2006, entitled “HIERARCHICAL TILE-BASED RASTERIZATION ALGORITHM” which is incorporated herein by reference.
- the per-tile, per-subtile, per-quad, and per-pixel clipping are performed at the same time as the per-tile, per-subtile, per-quad, and per-pixel rendering steps of the rasterization method.
- FIGS. 2 is a flow chart diagram illustrating clipping/culling procedure in the PA module of the graphics processing pipeline according to one embodiment of the present invention.
- a primitive such as a point, a line, or a triangle is assembled from vertices by the PA module in step 201 .
- a decision is made in step 202 as to if X, Y, or Z of all vertices of the primitive lie outside the view frustum. If the decision is yes, the primitive is culled in step 203 . If the decision is no, then another decision is made in step 204 as to if the nearest Z of any vertex is outside the view frustum. If the decision is yes, then near Z clipping is performed.
- the intersection with the view frustum may be computed and sent to the setup (SE) module; for a triangle, the intersection vertices are computed and one or more new triangles are built based on these vertices and sent to SE module. If the decision of step 204 is no, then the primitive is sent to the SE module without further processing.
- SE setup
- SE setup
- FIG. 3 is a flow chart diagram illustrating clipping/culling procedure in the SE module of the graphics processing pipeline according to one embodiment of the present invention.
- SE module computes initial points of rasterization to be used by the RA module for rendering the primitives in the rasterization process.
- a vertex inside the clipping window may be chosen as the initial point of rasterization. If all vertices are outside the clipping window, SE module performs necessary clipping and compute another initial point of rasterization.
- step 301 a near-Z clipped primitive, which is not trivially rejected in the PA module, is input to the SE module.
- step 302 a decision is made in step 302 as to if any vertices of the primitive is outside the far Z plane of the view frustum. If the decision is yes, then the entire primitive is culled in the far Z clipping/culling (step 309 ). If the decision of step 302 if no, then another decision is made in step 303 as to if the primitive is a line. For the case that the PA module is configured in the line mode and the primitive is a line, the method proceeds to step 304 where the decision is made as to if the starting vertex is outside the clipping window.
- the line is sent to the RA module (step 310 ). If the decision is yes, then the intersection of the line with the clipping window is computed in step 305 and a decision is made as to if the intersection is still outside the clipping window. For example, since the line is two-dimensional, only one coordinate is clipped. For example, if a line is x-major, the clipping is done by computing the y value at the nearest x clipping boundary (left or right border). The computed y-coordinate still needs to be verified if it is outside the clipping window. If the decision is yes, then the line is culled (step 309 ).
- step 310 the line is sent to the RA module with the computed intersections.
- step 303 for the case that the primitive is not a line, another decision is made in step 306 as to if any vertex of the primitive is inside the clipping rectangle. If no vertex is found inside the clipping window, the method proceeds to step 308 and intersections of each edge of the primitive with the clipping window are computed. If no intersection can be found that lies inside the clipping window, the entire primitive is culled (step 309 ). If any intersection exists, the primitive is sent to RA module with the first computed intersection as the initial point of rasterization (step 310 ).
- step 306 for the case that any vertex of the primitive is inside the clipping window, the vertex of the primitive that lies within the clipping window will be chosen to be the initial point of rasterization and the primitive is sent to RA module with the found vertex (step 307 ).
Abstract
A distributed clipping scheme is provided, view frustum culling is distributed in several places in a graphics processing pipeline to simplify hardware implementation and improve performance. In general, many 3D objects are outside viewing frustum. In one embodiment, clipping is performed on these objects with a simple algorithm in the PA module, such as near Z clipping, trivial rejection and trivial acceptance. In one embodiment, the SE and RA modules perform the rest of clipping, such as X, Y and far Z clipping. In one embodiment, the SE module performs clipping by way of computing a initial point of rasterization. In one embodiment, the RA module performs clipping by way of conducting the rendering step of the rasterization process. This approach distributes the complexity in the graphics processing pipeline and makes the design simpler and faster, therefore design complexity, cost and performance may all be improved in hardware implementation.
Description
- The present application relates to U.S. patent application Ser. No. 11/592,799 (Docket No. GIQUILA-P001), filed on Nov. 3, 2006, entitled “HIERARCHICAL TILE-BASED RASTERIZATION ALGORITHM” which is incorporated herein by reference.
- 1. Field of the Invention
- The invention relates generally to the field of computer systems and more particularly to 3D computer graphics processor.
- 2. Description of Related Art
- In 3D computer graphics, the view frustum is the region of a three dimensional space in the modeled world that may appear on a computer display screen represented by the 2D screen space (hereinafter also referred to as the screen space). The exact shape of the view frustum may vary, e.g. it may be a rectangular cube, a rectangular pyramid, or other suitable geometric shape. In an example, the frustum may be formed with six planes: near plane, far plane, +X plane, −X plane, +Y plane, and −Y plane. The planes that cut the view frustum perpendicular to the viewing direction are called the near plane and the far plane, which may also be called the near Z plane and the far Z plane.
- 3D objects in the view frustum may be represented by multiple geometric primitives, such as polygons, triangles, line segments, points, or other appropriate geometric elements. Geometric primitives that fall outside of the view frustum will not be visible and may be discarded, removed, or abandoned, in view frustum clipping, or culling, operation of the graphics processing pipeline. Here, culling refers to the complete removal of a geometric primitive which is completely outside of the view frustum while clipping refers to the partial removal of a geometric primitive which has a partial portion outside of the view frustum. Culling may be considered as a special case of clipping where the partial portion removed defaults to the complete geometric primitive. Clipping/culling 3D objects outside of the view frustum is not necessary to achieve a correct image output, but it accelerates the rendering process by eliminating the unneeded rasterization and post-processing on primitives that will not appear on the computer display screen anyway. Graphics processing pipeline typically includes a primitive assembly module (hereinafter referred to as the PA module) where 3D objects, which may be represented by multiple vertices computed from a vertex shader module, are converted to geometric primitives such as triangles, lines, points, polygons, or other appropriate geometric elements. For example, lines may be drawn from a starting-point (or starting-vertex) to an ending-point (or an ending-vertex) in order to pass conformance tests. The reason is that the ending-vertex may or may not be part of the line. PA module may also perform a conversion from the view frustum to the 2D screen space. In some examples, only the X and Y coordinates are transformed into screen space, while the per-pixel Z values may be stored in a Z-buffer. After processed by the PA module, the primitives are in the screen space. The rest of the pipe acts only on the screen space. In some examples, a clipping block may be added behind a primitive assembly block and before the SE module. In this case, the primitive assembly block would just assemble the primitives, the clipper block would clip the primitives and generate more primitives based on this clipping and than pass it on to a transformation pipe which transforms the clipped primitives to the screen space before it enters the SE module. This whole pipe including the primitive assembly block, clipper block, and the transformation pipe is called the PA module. Graphics processing pipelines typically also include a rasterization module (hereinafter referred to as the RA module) where all the pixels in a clipping window inside the 2D screen space are rendered. The RA module operates on the clipping window which may be a portion of the view frustum. Pixels in the screen space outside of the clipping window also need to be clipped/culled, i.e., discarded, removed, or abandoned. In addition to the primitive assembly module and the rasterization module, there may also be additional set up functions (e.g., computing an initial point of rasterization for a primitive) performed in a set up module (hereinafter referred to as the SE module). In the prior art, clipping/culling of 3D objects outside of the view frustum is typically done in a single place inside a graphics processing pipeline. Such an implementation can cause a bottleneck in the pipeline because of the large number of computation required for performing clipping/culling. For an example, view frustum clipping/culling may be done in the screen space. In this example, all the 3D objects are transformed to screen space and sent to the setup engine to do the clipping according to the clipping window. The advantage of this approach is that the hardware in the PA module may be very simple. The disadvantage is that all the 3D objects need to be transformed to screen space, even the objects outside of view frustum or clipping window. This may increase complexity and cost of the graphics processing pipeline implementation. In another example, all 6-plane clipping may be done in the view frustum before the conversion to the 2D screen space. The advantage of this approach is that all polygons outside of the view frustum are clipped; only the polygons inside the view frustum are transformed to screen space and sent to setup engine. The disadvantage of this approach is that the algorithm of doing 6 plane clipping is complex and expensive for hardware implementation.
- In general, in one aspect, the present invention involves a method for clipping in a 3D computer graphics processing pipeline, the 3D computer graphics processing pipeline comprises a view frustum, a clipping window, a primitive assembly (PA) module, a set up (SE) module, and a rasterization (RA) module, the method comprising: obtaining a primitive using the PA module; performing a first clipping of the primitive using the PA module; determining an initial point of rasterization for the primitive using the SE module; performing a second clipping of the primitive using the SE module; rendering the primitive using the RA module; and performing a third clipping of the primitive using the RA module.
- Other aspects and advantages of the invention will be apparent from the following description and the appended claims.
- So that the manner in which the above recited features, advantages and objects of the present invention are attained and can be understood in detail, a more particular description of the invention, briefly summarized above, may be had by reference to the embodiments thereof which are illustrated in the appended drawings.
- It is to be noted, however, that the appended drawings illustrate only typical embodiments of this invention and are therefore not to be considered limiting of its scope, for the present invention may admit to other equally effective embodiments.
-
FIG. 1 is a flow chart diagram illustrating an overall clipping/culling procedure of a graphics processing pipeline according to one embodiment of the present invention. -
FIG. 2 is a flow chart diagram illustrating clipping/culling procedure in the PA module of the graphics processing pipeline according to one embodiment of the present invention. -
FIG. 3 is a flow chart diagram illustrating clipping/culling procedure in the SE module of the graphics processing pipeline according to one embodiment of the present invention. -
FIG. 1 is a flow chart diagram illustrating an overall clipping/culling procedure of the graphics processing pipeline according to one embodiment of the present invention. As an example, the graphics processing pipeline includes the PA module, the SE module and the RA module. Here,step 102 receives multiple vertices representing 3D objects. In some examples, the vertices may be received from a vertex shader module which computes these vertices for representing 3D objects.Step 104 converts these 3D objects from vertices to geometric primitives, such as points, line segments (hereafter referred to as lines), triangles, or other appropriate geometric shapes. In an example, the PA module is configured in a triangle mode. In triangle mode, the vertices are converted into multiple triangles before any further processing. In another example, the PA module is configured in a line mode and converts the vertices into multiple lines before any further processing. In yet another example, the PA module is configured in point mode and converts the vertices into multiple points before any further processing. The points may be associated with a position attribute and a size attribute that may be used in rendering steps later in the graphics processing pipeline. Continuing the discussion ofstep 104, triangles and lines which are completely outside the view frustum are removed, which is known as trivial rejection to those skilled in the art. If any triangle or line is partially inside the view frustum and partially outside the view frustum, only near plane clipping, or near Z clipping, will be applied to the triangle or line. - In an example, step 104 may be implemented as the following algorithm where (Xc, Yc, Zc) is the coordinate of a vertex in the view frustum, which is bounded by six planes defined as (a) +X plane: Xc=Wc, (b) −X plane: Xc=−Wc, (c) +Y plane: Yc=Wc, (d) −Y plane: Yc=−Wc, (e) near Z plane: Zc=0, and (f) far Z plane: Zc=Wc. Here, the +X, −X, +Y and −Y planes form a X, Y clipping rectangle of the view frustum. The algorithm includes:
- (1) Perform clipping for the triangle and line mode, don't perform clipping for the point mode.
- (2) Check +X and −X planes, if all the vertices of triangle or line are Xc<−Wc or Xc>Wc, the triangle or line is culled.
- (3) Check +Y and −Y planes, if all the vertices of triangle or line are Yc<−Wc or Yc>Wc, the triangle or line is culled.
- (4) Check near Z and far Z planes, if all the vertices of triangle or line are Zc<0 or Zc>Wc, the triangle or line is culled.
- (5) Check near Z again, if some vertices' Zc<0 and some Zc>=0, perform near Z clipping.
- In the above exemplar algorithm, the near Z clipping may be performed by various methods known to one skilled in the art of 3D computer graphics. What is an important aspect of the present invention is that not all steps of view frustum clipping/culling are performed in one single location in the graphics processing pipeline.
- After clipping in the view frustum, the coordinates of primitives may be transformed to screen space in
step 106, and sent to the SE module and the RA module to perform the rest of the clipping. - Continuing the discussion of
FIG. 1 to step 108, the SE module determines the initial point of rasterization which must be inside the clipping window. Additional clipping/culling may be performed during this determination process. Here the clipping window resides in the screen space. In one example, the SE module starts with the vertices of a triangle or a line inside the clipping window as the initial point of rasterization. If none of the vertices are inside the clipping window, it computes the initial point of rasterization as a point which is both inside clipping window and inside the triangle or part of the line. As an example, if the vertices of a line are outside the clipping window, the SE module may compute the intersection of the line and the clipping window as the initial point of rasterization. If no such intersection can be found, the line is culled. In another example, where the PA module is configured in point mode, each point as a geometric primitive may be converted to a polygon with appropriate size according to the associated size attribute in the SE module. The polygon may be further converted as one or more triangles. Instep 110, the SE module implements the trivial rejection for the points after the polygon conversion. In an example, points are trivially rejected inside the PA module and the SE only culls if the entire primitive is outside the clipping window or beyond the far Z plane. In another example, the SE module performs trivial rejection (culling) if it cannot find any intersection with the clipping window or the primitive is beyond the far Z plane. In other examples, SE module may perform the trivial rejection to all geometric primitives including the triangles and lines for ease of implementation without having to differentiate between the modes in which the PA module is configured or to differentiate between geometric primitives. In one example, the trivial rejection is performed by way of computing the initial point of rasterization inside the clipping window. One skilled in the art will appreciate that the invention may be practice with SE module performing the trivial rejection either including or excluding the other geometric primitives. - In
step 112 ofFIG. 1 , the RA module performs per-tile, per-subtile, per-quad, and per-pixel clipping. Rasterization in the RA module may be implemented in various manners known to one skilled in the art of 3D computer graphics. In an example, the rasterization may be implemented in a hierarchical approach, such described in U.S. patent application Ser. No. 11/592,799 (Docket No. GIQUILA-P001), filed on Nov. 3, 2006, entitled “HIERARCHICAL TILE-BASED RASTERIZATION ALGORITHM” which is incorporated herein by reference. In this exemplary rasterization method, the per-tile, per-subtile, per-quad, and per-pixel clipping are performed at the same time as the per-tile, per-subtile, per-quad, and per-pixel rendering steps of the rasterization method. -
FIGS. 2 is a flow chart diagram illustrating clipping/culling procedure in the PA module of the graphics processing pipeline according to one embodiment of the present invention. Here, a primitive such as a point, a line, or a triangle is assembled from vertices by the PA module instep 201. A decision is made instep 202 as to if X, Y, or Z of all vertices of the primitive lie outside the view frustum. If the decision is yes, the primitive is culled instep 203. If the decision is no, then another decision is made in step 204 as to if the nearest Z of any vertex is outside the view frustum. If the decision is yes, then near Z clipping is performed. In an example, for a line, the intersection with the view frustum may be computed and sent to the setup (SE) module; for a triangle, the intersection vertices are computed and one or more new triangles are built based on these vertices and sent to SE module. If the decision of step 204 is no, then the primitive is sent to the SE module without further processing. -
FIG. 3 is a flow chart diagram illustrating clipping/culling procedure in the SE module of the graphics processing pipeline according to one embodiment of the present invention. In some examples, SE module computes initial points of rasterization to be used by the RA module for rendering the primitives in the rasterization process. In an example, a vertex inside the clipping window may be chosen as the initial point of rasterization. If all vertices are outside the clipping window, SE module performs necessary clipping and compute another initial point of rasterization. Here instep 301, a near-Z clipped primitive, which is not trivially rejected in the PA module, is input to the SE module. In some examples, only the X and Y coordinates are transformed into screen space, while the per pixel Z values are stored in a Z-buffer. Then a decision is made instep 302 as to if any vertices of the primitive is outside the far Z plane of the view frustum. If the decision is yes, then the entire primitive is culled in the far Z clipping/culling (step 309). If the decision ofstep 302 if no, then another decision is made instep 303 as to if the primitive is a line. For the case that the PA module is configured in the line mode and the primitive is a line, the method proceeds to step 304 where the decision is made as to if the starting vertex is outside the clipping window. If the decision is no, the line is sent to the RA module (step 310). If the decision is yes, then the intersection of the line with the clipping window is computed instep 305 and a decision is made as to if the intersection is still outside the clipping window. For example, since the line is two-dimensional, only one coordinate is clipped. For example, if a line is x-major, the clipping is done by computing the y value at the nearest x clipping boundary (left or right border). The computed y-coordinate still needs to be verified if it is outside the clipping window. If the decision is yes, then the line is culled (step 309). If the decision is no, then the line is sent to the RA module with the computed intersections (step 310). Continuing to the decision made instep 303, for the case that the primitive is not a line, another decision is made instep 306 as to if any vertex of the primitive is inside the clipping rectangle. If no vertex is found inside the clipping window, the method proceeds to step 308 and intersections of each edge of the primitive with the clipping window are computed. If no intersection can be found that lies inside the clipping window, the entire primitive is culled (step 309). If any intersection exists, the primitive is sent to RA module with the first computed intersection as the initial point of rasterization (step 310). Continuing to the decision made instep 306, for the case that any vertex of the primitive is inside the clipping window, the vertex of the primitive that lies within the clipping window will be chosen to be the initial point of rasterization and the primitive is sent to RA module with the found vertex (step 307). - Foregoing described embodiments of the invention are provided as illustrations and descriptions. They are not intended to limit the invention to precise form described. In particular, it is contemplated that functional implementation of invention described herein may be implemented equivalently in hardware, software, firmware, and/or other available functional components or building blocks, and that networks may be wired, wireless, or a combination of wired and wireless. Other variations and embodiments are possible in light of above teachings, and it is thus intended that the scope of invention not be limited by this Detailed Description, but rather by Claims following.
Claims (21)
1. A method for clipping in a 3D computer graphics processing pipeline, the 3D computer graphics processing pipeline comprises a view frustum, a clipping window, a primitive assembly (PA) module, a set up (SE) module, and a rasterization (RA) module, the method comprising:
obtaining a primitive using the PA module;
performing a first clipping of the primitive using the PA module;
determining an initial point of rasterization for the primitive using the SE module;
performing a second clipping of the primitive using the SE module;
rendering the primitive using the RA module; and
performing a third clipping of the primitive using the RA module.
2. The method of claim 1 , wherein the primitive comprises one or more vertex, and wherein the first clipping removes the primitive if the primitive has no vertex inside the view frustum.
3. The method of claim 1 , wherein the primitive comprises one or more vertices, and wherein the first clipping comprises a near Z clipping.
4. The method of claim 1 , wherein the primitive comprises one or more vertices, and wherein the second clipping comprises removing the primitive if the initial point of rasterization for the primitive can not be determined inside the clipping window.
5. The method of claim 1 , wherein the third clipping comprises:
(a) inputting the initial point of rasterization for the primitive;
(b) determining if the primitive is a line or a triangle; and
(c) if the primitive is a triangle, rasterizing the triangle in a hierarchical manner, comprising:
(c1) walking a plurality of tiles of pixels and determining if each tile is valid;
(c2) breaking each valid tile into a plurality of subtiles and determining if each subtile is valid;
(c3) breaking each valid subtile into a plurality of quads and determining if each quad is valid; and
(c4) rendering pixels for each valid quad, wherein steps (c1) through (c4) are performed in parallel.
6. The method of claim 5 , wherein the breaking step (c2) comprises:
(c2i) breaking each valid tile into the plurality of subtiles;
(c2ii) walking the plurality of subtiles; and
(c2iii) determining if each subtile is valid.
7. The method of claim 6 , wherein the walking of the plurality of subtiles is performed in a same manner as the walking of the plurality of tiles.
8. The method of claim 5 , wherein the breaking step (c3) comprises:
(c3i) breaking each valid subtile into the plurality of quads;
(c3ii) walking the plurality of quads; and
(c3iii) determining if each quad is valid.
9. The method of claim 8 , wherein the walking of the plurality of quads is performed in a same manner as the walking of the plurality of tiles and a walking of the plurality of subtiles.
10. The method of claim 5 , wherein validation of a block, wherein the block comprises a tile, a subtile, or a quad, comprises:
checking if a pixel in the block sits on the left, right, or exactly on a line of a triangle using edge equations;
checking four corners of the block against three edges of the triangle and returning a combined result;
determining if the block contains any pixels inside the triangle, based on the combined result; and
determining that the block is valid, if the block contains at least one valid pixel inside the triangle.
11. The method of claim 10 , further comprising:
abandoning the block, if the block does not contain at least one valid pixel inside the triangle.
12. The method of claim 5 , further comprising:
(d) if the primitive is a line, computing pixels for each quad of pixels for the line; and
(e) rendering pixels for each valid quad.
13. The method of claim 1 , wherein the primitive has a position and a size, and wherein the first clipping removes the primitive if the position is outside of the view frustum.
14. The method of claim 13 ,
wherein the primitive is converted into a polygon according to the size,
wherein the polygon is converted into a plurality of triangles in the SE module, and
wherein the second clipping removes a triangle if the triangle has no vertex inside the clipping window.
15. The method of claim 14 , wherein the third clipping comprises:
(a) inputting the initial point of rasterization for the triangle; and
(b) rasterizing the triangle in a hierarchical manner, comprising:
(b1) walking a plurality of tiles of pixels and determining if each tile is valid;
(b2) breaking each valid tile into a plurality of subtiles and determining if each subtile is valid;
(b3) breaking each valid subtile into a plurality of quads and determining if each quad is valid; and
(b4) rendering pixels for each valid quad, wherein steps (b1) through (b4) are performed in parallel.
16. The method of claim 15 , wherein the breaking step (b2) comprises:
(b2i) breaking each valid tile into the plurality of subtiles;
(b2ii) walking the plurality of subtiles; and
(b2iii) determining if each subtile is valid.
17. The method of claim 16 , wherein the walking of the plurality of subtiles is performed in a same manner as the walking of the plurality of tiles.
18. The method of claim 15 , wherein the breaking step (b3) comprises:
(b3i) breaking each valid subtile into the plurality of quads;
(b3ii) walking the plurality of quads; and
(b3iii) determining if each quad is valid.
19. The method of claim 18 , wherein the walking of the plurality of quads is performed in a same manner as the walking of the plurality of tiles and a walking of the plurality of subtiles.
20. The method of claim 15 , wherein validation of a block, wherein the block comprises a tile, a subtile, or a quad, comprises:
checking if a pixel in the block sits on the left, right, or exactly on a line of a triangle using edge equations;
checking four corners of the block against three edges of the triangle and returning a combined result;
determining if the block contains any pixels inside the triangle, based on the combined result; and
determining that the block is valid, if the block contains at least one valid pixel inside the triangle.
21. The method of claim 20 , further comprising:
abandoning the block, if the block does not contain at least one valid pixel inside the triangle.
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US12/783,433 US20100271370A1 (en) | 2007-01-24 | 2010-05-19 | Method for distributed clipping outside of view volume |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US11/657,966 US7746355B1 (en) | 2007-01-24 | 2007-01-24 | Method for distributed clipping outside of view volume |
US12/783,433 US20100271370A1 (en) | 2007-01-24 | 2010-05-19 | Method for distributed clipping outside of view volume |
Related Parent Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US11/657,966 Continuation US7746355B1 (en) | 2007-01-24 | 2007-01-24 | Method for distributed clipping outside of view volume |
Publications (1)
Publication Number | Publication Date |
---|---|
US20100271370A1 true US20100271370A1 (en) | 2010-10-28 |
Family
ID=39322543
Family Applications (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US11/657,966 Active 2028-08-25 US7746355B1 (en) | 2007-01-24 | 2007-01-24 | Method for distributed clipping outside of view volume |
US12/783,433 Abandoned US20100271370A1 (en) | 2007-01-24 | 2010-05-19 | Method for distributed clipping outside of view volume |
Family Applications Before (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US11/657,966 Active 2028-08-25 US7746355B1 (en) | 2007-01-24 | 2007-01-24 | Method for distributed clipping outside of view volume |
Country Status (4)
Country | Link |
---|---|
US (2) | US7746355B1 (en) |
EP (1) | EP1950706A2 (en) |
JP (1) | JP5058831B2 (en) |
KR (1) | KR20080069924A (en) |
Cited By (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20090092277A1 (en) * | 2007-10-04 | 2009-04-09 | Microsoft Corporation | Geo-Relevance for Images |
WO2016073125A1 (en) * | 2014-11-06 | 2016-05-12 | Intel Corporation | Zero-coverage rasterization culling |
CN107729665A (en) * | 2017-10-24 | 2018-02-23 | 北京空间技术研制试验中心 | A kind of spacecraft pipeline three-dimensional design system and method |
Families Citing this family (18)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US8542247B1 (en) | 2009-07-17 | 2013-09-24 | Nvidia Corporation | Cull before vertex attribute fetch and vertex lighting |
US8564616B1 (en) | 2009-07-17 | 2013-10-22 | Nvidia Corporation | Cull before vertex attribute fetch and vertex lighting |
US8384736B1 (en) * | 2009-10-14 | 2013-02-26 | Nvidia Corporation | Generating clip state for a batch of vertices |
US8976195B1 (en) | 2009-10-14 | 2015-03-10 | Nvidia Corporation | Generating clip state for a batch of vertices |
KR101068324B1 (en) * | 2009-10-28 | 2011-09-28 | 중앙대학교 산학협력단 | Rendering method on spherical coordinate system and system thereof |
US9064343B2 (en) | 2010-08-24 | 2015-06-23 | Qualcomm Incorporated | Graphics processing using two-dimensional scissor regions |
KR101681056B1 (en) | 2010-10-01 | 2016-12-01 | 삼성전자주식회사 | Method and Apparatus for Processing Vertex |
US9626792B2 (en) * | 2012-10-16 | 2017-04-18 | Adobe Systems Incorporated | Rendering an infinite plane |
KR102066533B1 (en) | 2013-11-19 | 2020-01-16 | 삼성전자 주식회사 | Method for domain shading and devices operating the same |
US9824412B2 (en) * | 2014-09-24 | 2017-11-21 | Intel Corporation | Position-only shading pipeline |
US9607414B2 (en) | 2015-01-27 | 2017-03-28 | Splunk Inc. | Three-dimensional point-in-polygon operation to facilitate displaying three-dimensional structures |
US9916326B2 (en) | 2015-01-27 | 2018-03-13 | Splunk, Inc. | Efficient point-in-polygon indexing technique for facilitating geofencing operations |
US10026204B2 (en) | 2015-01-27 | 2018-07-17 | Splunk Inc. | Efficient point-in-polygon indexing technique for processing queries over geographic data sets |
US9836874B2 (en) * | 2015-01-27 | 2017-12-05 | Splunk Inc. | Efficient polygon-clipping technique to reduce data transfer requirements for a viewport |
US9767122B2 (en) | 2015-01-27 | 2017-09-19 | Splunk Inc. | Efficient point-in-polygon indexing technique to facilitate displaying geographic data |
GB2565301A (en) | 2017-08-08 | 2019-02-13 | Nokia Technologies Oy | Three-dimensional video processing |
CN109712063B (en) * | 2018-12-12 | 2023-03-14 | 中国航空工业集团公司西安航空计算技术研究所 | Plane clipping circuit of graphic processor |
US11481967B2 (en) * | 2020-08-31 | 2022-10-25 | Advanced Micro Devices, Inc. | Shader core instruction to invoke depth culling |
Citations (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20020130886A1 (en) * | 2001-02-27 | 2002-09-19 | 3Dlabs Inc., Ltd. | Antialias mask generation |
US6618048B1 (en) * | 1999-10-28 | 2003-09-09 | Nintendo Co., Ltd. | 3D graphics rendering system for performing Z value clamping in near-Z range to maximize scene resolution of visually important Z components |
US7162716B2 (en) * | 2001-06-08 | 2007-01-09 | Nvidia Corporation | Software emulator for optimizing application-programmable vertex processing |
Family Cites Families (7)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5157764A (en) * | 1989-01-13 | 1992-10-20 | Sun Microsystems, Inc. | Apparatus and method for using a test window in a graphics subsystem which incorporates hardware to perform clipping of images |
US6771264B1 (en) * | 1998-08-20 | 2004-08-03 | Apple Computer, Inc. | Method and apparatus for performing tangent space lighting and bump mapping in a deferred shading graphics processor |
US7184059B1 (en) * | 2000-08-23 | 2007-02-27 | Nintendo Co., Ltd. | Graphics system with copy out conversions between embedded frame buffer and main memory |
JP2004102841A (en) * | 2002-09-11 | 2004-04-02 | Toshiba Corp | Clipping processing device, graphics system, clipping processing method, and the graphics method |
US7292242B1 (en) * | 2004-08-11 | 2007-11-06 | Nvida Corporation | Clipping with addition of vertices to existing primitives |
US7292254B1 (en) * | 2005-12-05 | 2007-11-06 | Nvidia Corporation | Apparatus, system, and method for clipping graphics primitives with reduced sensitivity to vertex ordering |
US7439988B1 (en) * | 2005-12-05 | 2008-10-21 | Nvidia Corporation | Apparatus, system, and method for clipping graphics primitives with respect to a clipping plane |
-
2007
- 2007-01-24 US US11/657,966 patent/US7746355B1/en active Active
-
2008
- 2008-01-15 JP JP2008005719A patent/JP5058831B2/en active Active
- 2008-01-23 KR KR1020080007147A patent/KR20080069924A/en not_active Application Discontinuation
- 2008-01-24 EP EP08100864A patent/EP1950706A2/en not_active Withdrawn
-
2010
- 2010-05-19 US US12/783,433 patent/US20100271370A1/en not_active Abandoned
Patent Citations (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6618048B1 (en) * | 1999-10-28 | 2003-09-09 | Nintendo Co., Ltd. | 3D graphics rendering system for performing Z value clamping in near-Z range to maximize scene resolution of visually important Z components |
US20020130886A1 (en) * | 2001-02-27 | 2002-09-19 | 3Dlabs Inc., Ltd. | Antialias mask generation |
US7162716B2 (en) * | 2001-06-08 | 2007-01-09 | Nvidia Corporation | Software emulator for optimizing application-programmable vertex processing |
Cited By (7)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20090092277A1 (en) * | 2007-10-04 | 2009-04-09 | Microsoft Corporation | Geo-Relevance for Images |
US8326048B2 (en) * | 2007-10-04 | 2012-12-04 | Microsoft Corporation | Geo-relevance for images |
WO2016073125A1 (en) * | 2014-11-06 | 2016-05-12 | Intel Corporation | Zero-coverage rasterization culling |
US10217272B2 (en) | 2014-11-06 | 2019-02-26 | Intel Corporation | Zero-coverage rasterization culling |
US10776994B2 (en) | 2014-11-06 | 2020-09-15 | Intel Corporation | Zero-coverage rasterization culling |
CN107729665A (en) * | 2017-10-24 | 2018-02-23 | 北京空间技术研制试验中心 | A kind of spacecraft pipeline three-dimensional design system and method |
CN107729665B (en) * | 2017-10-24 | 2021-01-05 | 北京空间技术研制试验中心 | Three-dimensional design system and method for spacecraft pipeline |
Also Published As
Publication number | Publication date |
---|---|
JP5058831B2 (en) | 2012-10-24 |
JP2008181514A (en) | 2008-08-07 |
US7746355B1 (en) | 2010-06-29 |
EP1950706A2 (en) | 2008-07-30 |
KR20080069924A (en) | 2008-07-29 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US7746355B1 (en) | Method for distributed clipping outside of view volume | |
US11861792B2 (en) | Tessellation of patches of surfaces in a tile based rendering system | |
JP5111638B2 (en) | Apparatus and method for dividing a parametric curve into smaller subpatches | |
US6791540B1 (en) | Image processing apparatus | |
US7348989B2 (en) | Preparing digital images for display utilizing view-dependent texturing | |
KR100866573B1 (en) | A point-based rendering method using visibility map | |
KR101351236B1 (en) | A tessellator whose tessellation time grows linearly with the amount of tessellation | |
US7126600B1 (en) | Method and apparatus for high speed block mode triangle rendering | |
US20100073368A1 (en) | Methods and systems to determine conservative view cell occlusion | |
US20090046098A1 (en) | Primitive binning method for tile-based rendering | |
US20040227755A1 (en) | Bicubic surface real-time tesselation unit | |
KR101681056B1 (en) | Method and Apparatus for Processing Vertex | |
EP1496475A1 (en) | A geometric processing stage for a pipelined graphic engine, corresponding method and computer program product therefor | |
EP3346448A1 (en) | Graphics processing method and system | |
EP2410492A2 (en) | Optimal point density using camera proximity for point-based global illumination | |
CN115147579B (en) | Block rendering mode graphic processing method and system for expanding block boundary | |
US5986669A (en) | Graphics processing with efficient clipping | |
TW201310393A (en) | Stochastic rasterization with selective culling | |
WO1999052082A1 (en) | Guard region and hither plane vertex modification for graphics rendering | |
US8068120B2 (en) | Guard band clipping systems and methods | |
US20130050211A1 (en) | Rasterization engine and three-dimensional graphics system for rasterizing in order adapted to characteristics of polygon | |
JP2002352254A (en) | Method for rendering mesh including a plurality of polygons representing graphics models | |
EP1197922A2 (en) | Apparatus, system, and method for simplifying annotations on a geometric surface | |
Yu | Efficient visibility processing for projective texture mapping | |
KR20180117499A (en) | Apparatus and method for simplification of 3D mesh data |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: VIVANTE CORPORATION, CALIFORNIA Free format text: CHANGE OF NAME;ASSIGNOR:GIQUILA CORPORATION;REEL/FRAME:024687/0088 Effective date: 20070426 Owner name: GIQUILA CORPORATION, CALIFORNIA Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:CAI, MIKE M.;TAN, LIN;GARRITSEN, FRIDO;AND OTHERS;SIGNING DATES FROM 20070116 TO 20070117;REEL/FRAME:024685/0177 |
|
STCB | Information on status: application discontinuation |
Free format text: ABANDONED -- FAILURE TO RESPOND TO AN OFFICE ACTION |