DETAILED ACTION
Notice of Pre-AIA or AIA Status
1. The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
Status of Claims
2. Claims 1-12, 14, 16-18, and 20 have been amended.
3. Claims 13, 15, and 19 are as previously presented.
Claim Rejections - 35 USC § 103
4. In the event the determination of the status of the application as subject to AIA 35 U.S.C. 102 and 103 (or as subject to pre-AIA 35 U.S.C. 102 and 103) is incorrect, any correction of the statutory basis (i.e., changing from AIA to pre-AIA ) for the rejection will not be considered a new ground of rejection if the prior art relied upon, and the rationale supporting the rejection, would be the same under either status.
5. The following is a quotation of 35 U.S.C. 103 which forms the basis for all obviousness rejections set forth in this Office action:
A patent for a claimed invention may not be obtained, notwithstanding that the claimed invention is not identically disclosed as set forth in section 102, if the differences between the claimed invention and the prior art are such that the claimed invention as a whole would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to which the claimed invention pertains. Patentability shall not be negated by the manner in which the invention was made.
6. Claims 1-4, 7-9, 11-14, 16-18, 20 are rejected under 35 U.S.C. 103 as being unpatentable over Surti (US 10037621 B2), hereinafter Surti, in view of Laine (Samuli Laine and Tero Karras. 2011. High-performance software rasterization on GPUs. In Proceedings of the ACM SIGGRAPH Symposium on High Performance Graphics (HPG '11). Association for Computing Machinery, New York, NY, USA, 79–88. https://doi.org/10.1145/2018323.2018337), hereinafter Laine.
Regarding claim 1, Surti teaches a rasterizing method performed by a computer device, the method comprising: obtaining primitive data of a plurality of triangles of a three-dimensional model in a three-dimensional space (Fig. 8, Col. 13 lines 26-59, wherein an input 3D object can be tessellated into geometric objects which are processed to obtain vertex data, wherein a tessellated 3D object is interpreted as a plurality of triangles of a 3D model, and vertex data is interpreted as primitive data); performing a first coverage test on the plurality of triangles and a plurality of first blocks through n thread blocks (Fig. 6, Col. 10 lines 31-54, wherein geometry is processed via threads executing on N executing units) to obtain first data corresponding to the plurality of a first target block among the plurality of first blocks (Fig. 15-17, Col. 20 line 54 – Col. 21 line 51, wherein the “megaspan” blocks are interpreted as a plurality of first blocks, and coverage tests suggest obtaining coverage data for each one of those blocks including a first target block) respectively, the first data comprising primitive data of a first triangle cluster that intersects with a respective one of the first blocks (Fig. 14, Col. 20 lines 7-52, wherein the rasterizer computes vertical/horizontal extent, bounding box, and vertex values of the triangles, which is interpreted as primitive data of a first triangle cluster which includes the triangles intersecting with the first blocks, and wherein a span is defined as the area enclosing a triangle), and n being a positive integer; performing a second coverage test on a first triangle cluster of a first target block (Fig. 15-16, Col. 20 line 54 – Col. 21 line 16, wherein the “superspan” blocks which are subsections of the “megaspan” block is interpreted as a first target block, and are traversed based on whether the megaspan is partially covered by triangles, which is interpreted as performing a second coverage test based on the first data) and a plurality of second blocks of the first target block through the n thread blocks based on the first data to obtain second data corresponding to the plurality of second blocks (Fig. 15-16, Col. 20 line 54 – Col. 21 line 16, wherein the “span” blocks which are subsections of the “superspan” block is interpreted as a plurality of second blocks of the first target block, and are traversed based on whether the superspan is partially covered by triangles, which is interpreted as performing a second coverage test based on the first data) respectively, the second data comprising primitive data of a second triangle cluster that intersects with a respective one of the second blocks (Fig. 14, Col. 20 lines 7-52, wherein the rasterizer computes vertical/horizontal extent, bounding box, and vertex values of the triangles, which is interpreted as primitive data of triangles which includes a second triangle cluster intersecting with the second blocks), the second triangle cluster being a subset of the first triangle cluster (Fig. 15, Col. 20 lines 54-63, wherein “span” blocks are obtained by dividing up a “superspan” block, which is interpreted as a plurality of second blocks being obtained by dividing the first target block), and the plurality of the second blocks are obtained by dividing the first target block (Fig. 16, Col. 21 lines 4-30, wherein performing coverage tests on a megaspan to obtain coverage data for a first triangle cluster, then determining a finer level of coverage by performing coverage tests on spans to obtain coverage data for a second triangle cluster, where the spans are subsections of the span, and coverage tests are performed for the same primitive, suggests that the second triangle cluster is a subset of the first triangle cluster).
Surti does not teach a plurality of first blocks of a camera view port, and rendering triangles in the second triangle cluster of a second target block to pixels in the second target block, the second target block being any one of the plurality of second blocks.
Laine teaches a plurality of first blocks of a camera view port (Section 4.1 paragraph 3; Section 5.1, wherein the viewport being divided into bins is interpreted as blocks of a camera viewpoint), and rendering triangles in the second triangle cluster of a second target block to pixels in the second target block, the second target block being any one of the plurality of second blocks (Fig. 1, section 5.4, wherein shading the associated tile’s framebuffer based on the triangles inputted for the tile is interpreted as rendering triangles to pixels in a second target block, wherein tiles are interpreted as a plurality of second blocks).
It would be obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to have modified Surti to incorporate the teachings of Laine for this rasterizing method. Surti discusses a hierarchical rasterization method, by coverage testing blocks of pixels at a time, then deciding whether to perform further coverage testing on subsections of those blocks, in order to reduce the number of computations needed to perform rasterization by reducing redundant coverage testing. Similarly, Laine discusses a rasterization pipeline where triangles are processed and rasterized into bins, and then further rasterized into tiles, which are subsections of the bins. This is done in order to save on bandwidth and memory, and to have the entire rasterization process be able to run on software only. Both of these references discuss rasterization techniques involving performing multiple coverage tests on subsections of an area, in order to perform rasterization more efficiently. Because of this, it would be obvious to combine these references.
Regarding claim 2, Surti in view of Laine disclose the method of claim 1. Additionally, Laine teaches the method according to claim 1, wherein the performing a first coverage test on the plurality of triangles and a plurality of first blocks of a camera viewport through n thread blocks to obtain first data corresponding to the plurality of first blocks respectively comprises: performing the first coverage test on the plurality of triangles and the plurality of first blocks of the camera viewport in parallel through the n thread blocks to determine the primitive data of the first triangle cluster that intersects with the first target block (Section 4.2, wherein the rasterization process is parallelized and each bin is processed in parallel, wherein the bins are interpreted as a plurality of first blocks); and storing in parallel, through the n thread blocks, triangles that intersect with the first target block, to obtain n first linked lists corresponding to the first target block (Fig. 1, Section 5.3, wherein for each bin, triangle are written to per-tile queues, which are defined as a type of linked list and correspond to their given bin); wherein in a single round of parallel computation, one of the n thread blocks processes p*q triangles among the plurality of triangles (Sections 5.2-5.3, wherein the numbers of triangles processed is based on the numbers of calls to action (CTAs) and warps, which are integer values, which suggests the thread blocks processes p * q triangles), an ith first linked list among the n first linked lists is used for storing first coverage test results of an ith block, the ith first linked list comprises at least one node, and the node stores index data of the p*q triangles that intersect with the first target block (Fig. 1, Sections 5.2-5.3, wherein triangles are written into per-tile queues based on the bins each triangle covers, which is interpreted as storing first coverage test results in linked list nodes, and includes index data); and wherein the n thread blocks determine, through rounds of computation, the first triangle cluster that intersects with the first target block (Fig 1, section 5.3, wherein determining which bins the triangles cover and writing their triangle data is interpreted as finding the first triangle cluster that intersects with the first target block), wherein i is a positive integer not greater than n; n, p, and q are positive integers; and p*q represents a product of p and q.
The motivation to combine would be the same as that set forth for claim 1.
Regarding claim 3, Surti in view of Laine discloses the method of claim 2. Additionally, Laine teaches the method according to claim 2, wherein the first coverage test comprises a producer stage and a consumer stage (Fig. 1, wherein the triangle setup stage is interpreted as a producer stage, and the rasterizer stages are interpreted as a consumer stage); the performing the first coverage test on the plurality of triangles and the plurality of first blocks of the camera viewport in parallel through the n thread blocks comprises: uploading, in the producer stage, n batches of triangles from a global graphics memory to a cache through the n thread blocks in the single round of parallel computation, a batch of triangles comprising p*q triangles among the plurality of triangles (Fig. 1, section 5.1, wherein a number of triangles are inputted and processed in parallel threads, and are inputted from a separate array created by a previously executed vertex shader, which suggests being from a global graphics memory), and performing, in the consumer stage, the first coverage test on the n batches of triangles and the plurality of first blocks through the n thread blocks in the single round of parallel computation (Fig. 1, sections 5.2-5.3, wherein a coverage test for each batch of triangles is performed to determine which bins they cover for each bin on multiple threads, wherein the bins are interpreted as a plurality of first blocks); and the storing in parallel, through the n thread blocks, triangles that intersect with the first target block, to obtain n first linked lists corresponding to the first target block comprises: storing in parallel, through the n thread blocks, indexes of the plurality of triangles that intersect with the first target block to the n first linked lists of the first target block (Fig. 1, section 5.2, wherein for each bin, triangles are written to a number of per-CTA queues, which are interpreted as first linked lists corresponding to a given target block), wherein there is a one-to-one corresponding relationship between the n thread blocks and the n first linked lists (Fig. 1, section 5.2, wherein each call to action (CTA) processes their separate per-CTA queue, wherein a CTA is interpreted as a thread block).
The motivation to combine would be the same as that set forth for claim 1.
Regarding claim 4, Surti in view of Laine discloses the method of claim 3. Additionally, Laine teaches the method according to claim 3, wherein each of the thread blocks comprises p warps, and each warp comprises q threads (5.2 paragraph 1, wherein each CTA comprises a given number of warps which each contain a given number of threads); the performing, in the consumer stage, the first coverage test on the n batches of triangles and the plurality of first blocks through the n thread blocks in the single round of parallel computation comprises: performing, in the consumer stage, for the ith block among the n thread blocks, the first coverage test on an ith batch of triangles among the n batches and the plurality of first blocks through p*q threads in the ith block in the single round of parallel computation to obtain a first coverage template (Section 5.2, wherein determining and tagging which bin teach triangles cover into a bit matrix is interpreted as obtaining a first coverage template), wherein the first coverage template stores the number and indexes of triangles that intersect with each first block (Section 5.2, wherein tagging the triangles and which bin they cover suggests storing the numbers and indexes of triangles and whether the intersect with each block); and the storing in parallel, through the n thread blocks, indexes of the plurality of triangles that intersect with the first target block to the n first linked lists of the first target block comprises: storing, in the single round of parallel computation, the indexes of the plurality of triangles that intersect with the first target block to one node of the ith first linked list through the ith block in a first to-be-processed linked list space (Section 5.2, wherein the output indices of triangles and which bins they cover are calculated and stored in output queues in the same order they were inputted in, which are interpreted as a first-to-be-processed linked list space), wherein the ith block corresponds to the ith batch of triangles, and the first to-be-processed linked list space is a storage space used for storing one node of the ith first linked list in the global graphics memory (Section 5.2, wherein the output queues being flushed for each input batch suggests the first-to-be-processed linked list space is a temporary storage space used for storing a portion of a linked list in memory).
The motivation to combine would be the same as that set forth for claim 1.
Regarding claim 7, Surti in view of Laine discloses the method of claim 1. Additionally, Laine teaches the method according to claim 1, wherein the performing a second coverage test on a first triangle cluster and a plurality of second blocks through n thread blocks to obtain second data corresponding to the plurality of second blocks respectively comprises: performing the second coverage test on the first triangle cluster and the plurality of second blocks in parallel through the n thread blocks to determine primitive data of the second triangle cluster that intersects with the second target block (Fig. 2, section 5.4, wherein all threads calculate coverage for input triangles, which is interpreted as determining primitive data intersecting with blocks, wherein the input triangles is a set of triangles corresponding to the tiles, which is interpreted as a second triangle cluster and the tiles are interpreted a plurality of second blocks); and storing in parallel, through the n thread blocks, triangles that intersect with the second target block, to obtain 1 second linked list corresponding to the second target block (Fig. 2, Section 5.4, processing input triangles and writing the frame buffer tile containing the triangles and their intersections for each tile, wherein the frame buffer is interpreted as a type of list that corresponds with a given tile); wherein in the single round of parallel computation, one of the n thread blocks processes p*q triangles in the first triangle cluster, the second linked list comprises at least one node, and the node stores index data of q triangles that intersect with the second target block (Section 5.4, wherein the number of triangles processed depends on the number of warps, streaming multiprocessors (SMs), and memory available, which suggests processing p * q triangles where p and q are integers; wherein the framebuffer tile stores index data for a given number of triangles); and wherein the n thread blocks determine, through rounds of computation, the second triangle cluster that intersects with the second target block (Fig. 2, 5.4, wherein the fine rasterizer determines the tiles a given set of triangles cover, which is interpreted as determining the second triangle cluster that intersects with the second target block), wherein n, p, and q are positive integers.
The motivation to combine would be the same as that set forth for claim 1.
Regarding claim 8, Surti in view of Laine discloses the method of claim 7. Additionally, Laine teaches the method according to claim 7, wherein the second coverage test comprises a producer stage and a consumer stage (Section 5.4, wherein the fine rasterizer section is divided into an input and shader phase); the performing the second coverage test on the first triangle cluster and the plurality of second blocks in parallel through the n thread blocks comprises: uploading, in the producer stage, the n batches of triangles from the global graphics memory to the cache through the n thread blocks in the single round of parallel computation, a batch of triangles comprising p*q triangles in the first triangle cluster (Section 5.4, paragraphs 1-2, wherein triangles are inputted from per-tile queues stored in a shared memory, wherein threads in parallel process a given number of triangles), and performing, in the consumer stage, the second coverage test on the n batches of triangles and the plurality of second blocks through the n thread blocks in the single round of parallel computation (Fig. 2, section 5.4, wherein determining in the shading phase what fragment should be shaded based on the triangles is interpreted as a second coverage test); and the storing in parallel, through the n thread blocks, triangles that intersect with the second target block, to obtain 1 second linked list corresponding to the second target block comprises: storing indexes of the plurality of triangles that intersect with the second target block to the 1 second linked list of the second target block in parallel through the n thread blocks (Fig. 2, section 5.4, processing input triangles and writing the frame buffer tile containing the triangle and its intersections for each tile, wherein the frame buffer is interpreted as a list that corresponds to a tile which is interpreted as a second block).
The motivation to combine would be the same as that set forth for claim 1.
Regarding claim 9, Surti in view of Laine discloses the method of claim 8. Additionally, Laine teaches the method according to claim 8, wherein each of the thread blocks comprises p warps, and each warp comprises q threads (Fig. 1, section 5.4, wherein each tile is processed in a given number of warps, with each warp consisting of a given number of threads processing each triangle separately); the performing, in the consumer stage, the second coverage test on the n batches of triangles and the plurality of second blocks through the n thread blocks in the single round of parallel computation comprises: performing, in the consumer stage, for the ith block among the n thread blocks, the second coverage test on the ith batch of triangles among the n batches and the plurality of second blocks through the p*q threads in the ith block in the single round of parallel computation to obtain a second coverage template, wherein the second coverage template stores the number and indexes of triangles that intersect with each second block (Fig. 2, section 5.4, wherein determining in the shading phase what fragment should be shaded based on the triangles is interpreted as a coverage test, and obtaining a bitmask that is used to determine the indices of the triangles and fragments that should be shaded is interpreted as obtaining a second coverage template); and the storing indexes of the plurality of triangles that intersect with the second target block to the 1 second linked list of the second target block in parallel through the n thread blocks comprises: storing, in the single round of parallel computation, the indexes of the plurality of triangles that intersect with the second target block to one node of the 1 second linked list through the ith block in the second to-be-processed linked list space, wherein the ith block corresponds to the ith batch of triangles, and the second to-be-processed linked list space is a storage space used for storing one node of the 1 second linked list in the global graphics memory (Fig. 2 section 5.4, processing input triangles and writing to a ring buffer in shared memory before writing to a frame buffer containing the index and intersection information for the triangles, wherein the frame buffer is interpreted as a list that corresponds to a tile, and the ring buffer is interpreted as a second-to-be-processed linked list space for storing information for a portion of a second linked list in a global graphics memory).
The motivation to combine would be the same as that set forth for claim 1.
Regarding claim 11, Surti in view of Laine discloses the method of claim 1. Additionally, Surti teaches the method according to claim 1, wherein the rendering triangles in the second triangle cluster of a second target block to pixels in the second target block comprises: determining, for any triangle in the second triangle cluster corresponding to the second target block, an intersection region between the triangle and the second target block (Fig. 15-16, Col. 20 line 54 – Col. 21 line 17, wherein calculating the coverage of a triangle over a given span is interpreted as determining an intersection region between a given triangle and the second target block, wherein the triangle can include triangles in a second triangle cluster, and the spans can include a second target block); storing fragment data of the intersection region of the triangle to the cache (Fig. 8, 13, Col. 19 line 49 – Col. 20 line 6, wherein fragments are written to a render target, wherein the render target is defined as consisting of a cache); and rendering the fragment data of the triangle into pixels in the intersection region of the second target block (Fig. 8, Col. 13 lines 49-59, wherein the render output pipeline has pixel shaders to convert geometric objects into per pixel representations, which is interpreted as rendering fragment data into pixels).
Regarding claim 12, Surti in view of Laine discloses the method of claim 11. Additionally, Laine teaches the method according to claim 11, wherein the determining an intersection region between the triangle and the second target block comprises: querying, in a pre-constructed triangle coverage pixel query table, the intersection region between the triangle and the second target block through edge attributes of the triangle (Fig. 3, section 5.4, determining the coverage of a triangle based on a look-up table determined by the edges of a triangle, wherein a look-up-table is interpreted as a query table), wherein the triangle coverage pixel query table is used for simulating a position relationship between the triangle and the second target block (Fig. 3, section 5.4, wherein using a look up table to determine the coverage of the triangle and a target block suggests simulating the triangle’s position), and the edge attributes comprise slopes of edges of the triangle, intersection points between the edges and boundaries of the second target block, and starting directions of the edges (Fig. 3, wherein the slope, position, coverage, and height of the triangle edges are used to query the look-up table, which suggests also using the starting directions of the edges).
The motivation to combine would be the same as that set forth for claim 1.
Regarding claim 13, Surti in view of Laine discloses the method of claim 11. Additionally, Laine teaches the method according to claim 11, wherein the rendering the fragment data of the triangle into pixels in the intersection region of the second target block comprises: preferentially inputting the fragment data corresponding to the triangle with a smaller index when at least two triangles input at least two fragment data to a same pixel in the intersection region (Section 5.4, paragraph 7-8, wherein earlier triangles prevailing over later triangles in write conflicts under specific settings is interpreted as preferentially inputting fragment data corresponding to a triangle with a smaller index).
The motivation to combine would be the same as that set forth for claim 1.
Regarding claim 14, Surti in view of Laine discloses the method of claim 1. Additionally, Laine teaches the method according to claim 1, wherein before the performing a first coverage test on the plurality of triangles and a plurality of first blocks of a camera viewport through n thread blocks to obtain first data corresponding to the plurality of first blocks respectively, the method further comprises: filtering the plurality of triangles of the three-dimensional model in the three-dimensional space by: removing triangles outside the camera viewport from the plurality of triangles of the three-dimensional model (Section 5.1, view frustum culling interpreted as removing triangles outside the camera viewport); clipping triangles with sub-regions located within the camera viewport from the plurality of triangles of the three-dimensional model (Section 5.1, far and near plane clipping interpreted as clipping triangles in sub-regions located within the camera viewport); and removing triangles, bounding boxes of which are not greater than a pixel and do not cover diagonal points of the pixel, from the plurality of triangles of the three-dimensional model (Section 5.1, wherein culling triangles with zero area, or with a bounding box that falls between samples is interpreted as removing triangles with bounding boxes that are smaller than a pixel or is not covering a pixel, wherein a sample can be a pixel, and a bounding box not covering a pixel suggests that it does not cover diagonal points of the pixel).
The motivation to combine would be the same as that set forth for claim 1.
Regarding claim 16, Surti teaches a computer device, comprising: obtaining primitive data of a plurality of triangles of a three-dimensional model in a three-dimensional space (Fig. 8, Col. 13 lines 26-59, wherein an input 3D object can be tessellated into geometric objects which are processed to obtain vertex data, wherein a tessellated 3D object is interpreted as a plurality of triangles of a 3D model, and vertex data is interpreted as primitive data); performing a first coverage test on the plurality of triangles and a plurality of first blocks through n thread blocks (Fig. 6, Col. 10 lines 31-54, wherein geometry is processed via threads executing on N executing units) to obtain first data corresponding to the plurality of a first target block among the plurality of first blocks (Fig. 15-17, Col. 20 line 54 – Col. 21 line 51, wherein the “megaspan” blocks are interpreted as a plurality of first blocks, and coverage tests suggest obtaining coverage data for each one of those blocks including a first target block) respectively, the first data comprising primitive data of a first triangle cluster that intersects with a respective one of the first blocks (Fig. 14, Col. 20 lines 7-52, wherein the rasterizer computes vertical/horizontal extent, bounding box, and vertex values of the triangles, which is interpreted as primitive data of a first triangle cluster which includes the triangles intersecting with the first blocks, and wherein a span is defined as the area enclosing a triangle), and n being a positive integer; performing a second coverage test on a first triangle cluster of a first target block (Fig. 15-16, Col. 20 line 54 – Col. 21 line 16, wherein the “superspan” blocks which are subsections of the “megaspan” block is interpreted as a first target block, and are traversed based on whether the megaspan is partially covered by triangles, which is interpreted as performing a second coverage test based on the first data) and a plurality of second blocks of the first target block through the n thread blocks based on the first data to obtain second data corresponding to the plurality of second blocks (Fig. 15-16, Col. 20 line 54 – Col. 21 line 16, wherein the “span” blocks which are subsections of the “superspan” block is interpreted as a plurality of second blocks of the first target block, and are traversed based on whether the superspan is partially covered by triangles, which is interpreted as performing a second coverage test based on the first data) respectively, the second data comprising primitive data of a second triangle cluster that intersects with a respective one of the second blocks (Fig. 14, Col. 20 lines 7-52, wherein the rasterizer computes vertical/horizontal extent, bounding box, and vertex values of the triangles, which is interpreted as primitive data of triangles which includes a second triangle cluster intersecting with the second blocks), the second triangle cluster being a subset of the first triangle cluster (Fig. 15, Col. 20 lines 54-63, wherein “span” blocks are obtained by dividing up a “superspan” block, which is interpreted as a plurality of second blocks being obtained by dividing the first target block), and the plurality of the second blocks are obtained by dividing the first target block (Fig. 16, Col. 21 lines 4-30, wherein performing coverage tests on a megaspan to obtain coverage data for a first triangle cluster, then determining a finer level of coverage by performing coverage tests on spans to obtain coverage data for a second triangle cluster, where the spans are subsections of the span, and coverage tests are performed for the same primitive, suggests that the second triangle cluster is a subset of the first triangle cluster).
Surti does not teach a plurality of first blocks of a camera view port, and rendering triangles in the second triangle cluster of a second target block to pixels in the second target block, the second target block being any one of the plurality of second blocks.
Laine teaches a plurality of first blocks of a camera view port (Section 4.1 paragraph 3; Section 5.1, wherein the viewport being divided into bins is interpreted as blocks of a camera viewpoint), and rendering triangles in the second triangle cluster of a second target block to pixels in the second target block, the second target block being any one of the plurality of second blocks (Fig. 1, section 5.4, wherein shading the associated tile’s framebuffer based on the triangles inputted for the tile is interpreted as rendering triangles to pixels in a second target block, wherein tiles are interpreted as a plurality of second blocks).
The motivation to combine would be the same as that set forth for claim 1.
Regarding claim 17, Surti in view of Laine discloses the apparatus of claim 16. Additionally, Surti teaches the device according to claim 16, wherein the rendering triangles in the second triangle cluster of a second target block to pixels in the second target block comprises: determining, for any triangle in the second triangle cluster corresponding to the second target block, an intersection region between the triangle and the second target block (Fig. 15-16, Col. 20 line 54 – Col. 21 line 17, wherein calculating the coverage of a triangle over a given span is interpreted as determining an intersection region between a given triangle and the second target block, wherein the triangle can include triangles in a second triangle cluster, and the spans can include a second target block); storing fragment data of the intersection region of the triangle to the cache (Fig. 8, 13, Col. 19 line 49 – Col. 20 line 6, wherein fragments are written to a render target, wherein the render target is defined as consisting of a cache); and rendering the fragment data of the triangle into pixels in the intersection region of the second target block (Fig. 8, Col. 13 lines 49-59, wherein the render output pipeline has pixel shaders to convert geometric objects into per pixel representations, which is interpreted as rendering fragment data into pixels).
Regarding claim 18, Surti in view of Laine discloses the device of claim 16. Additionally, Laine teaches the device according to claim 16, wherein before the performing a first coverage test on the plurality of triangles and a plurality of first blocks of a camera viewport through n thread blocks to obtain first data corresponding to the plurality of first blocks respectively, the method further comprises: filtering the plurality of triangles of the three-dimensional model in the three-dimensional space by: removing triangles outside the camera viewport from the plurality of triangles of the three-dimensional model (Section 5.1, view frustum culling interpreted as removing triangles outside the camera viewport); clipping triangles with sub-regions located within the camera viewport from the plurality of triangles of the three-dimensional model (Section 5.1, far and near plane clipping interpreted as clipping triangles in sub-regions located within the camera viewport); and removing triangles, bounding boxes of which are not greater than a pixel and do not cover diagonal points of the pixel, from the plurality of triangles of the three-dimensional model (Section 5.1, wherein culling triangles with zero area, or with a bounding box that falls between samples is interpreted as removing triangles with bounding boxes that are smaller than a pixel or is not covering a pixel, wherein a sample can be a pixel, and a bounding box not covering a pixel suggests that it does not cover diagonal points of the pixel).
The motivation to combine would be the same as that set forth for claim 1.
Regarding claim 20, Surti teaches a non-transitory computer-readable storage medium, the computer-readable storage medium storing a computer program (Fig. 1, computer processing system 100 with processor and memory), and the computer program being loaded and executed by a processor of a computer device and causing the computer device to implement a rasterizing method including: obtaining primitive data of a plurality of triangles of a three-dimensional model in a three-dimensional space (Fig. 8, Col. 13 lines 26-59, wherein an input 3D object can be tessellated into geometric objects which are processed to obtain vertex data, wherein a tessellated 3D object is interpreted as a plurality of triangles of a 3D model, and vertex data is interpreted as primitive data); performing a first coverage test on the plurality of triangles and a plurality of first blocks through n thread blocks (Fig. 6, Col. 10 lines 31-54, wherein geometry is processed via threads executing on N executing units) to obtain first data corresponding to the plurality of a first target block among the plurality of first blocks (Fig. 15-17, Col. 20 line 54 – Col. 21 line 51, wherein the “megaspan” blocks are interpreted as a plurality of first blocks, and coverage tests suggest obtaining coverage data for each one of those blocks including a first target block) respectively, the first data comprising primitive data of a first triangle cluster that intersects with a respective one of the first blocks (Fig. 14, Col. 20 lines 7-52, wherein the rasterizer computes vertical/horizontal extent, bounding box, and vertex values of the triangles, which is interpreted as primitive data of a first triangle cluster which includes the triangles intersecting with the first blocks, and wherein a span is defined as the area enclosing a triangle), and n being a positive integer; performing a second coverage test on a first triangle cluster of a first target block (Fig. 15-16, Col. 20 line 54 – Col. 21 line 16, wherein the “superspan” blocks which are subsections of the “megaspan” block is interpreted as a first target block, and are traversed based on whether the megaspan is partially covered by triangles, which is interpreted as performing a second coverage test based on the first data) and a plurality of second blocks of the first target block through the n thread blocks based on the first data to obtain second data corresponding to the plurality of second blocks (Fig. 15-16, Col. 20 line 54 – Col. 21 line 16, wherein the “span” blocks which are subsections of the “superspan” block is interpreted as a plurality of second blocks of the first target block, and are traversed based on whether the superspan is partially covered by triangles, which is interpreted as performing a second coverage test based on the first data) respectively, the second data comprising primitive data of a second triangle cluster that intersects with a respective one of the second blocks (Fig. 14, Col. 20 lines 7-52, wherein the rasterizer computes vertical/horizontal extent, bounding box, and vertex values of the triangles, which is interpreted as primitive data of triangles which includes a second triangle cluster intersecting with the second blocks), the second triangle cluster being a subset of the first triangle cluster (Fig. 15, Col. 20 lines 54-63, wherein “span” blocks are obtained by dividing up a “superspan” block, which is interpreted as a plurality of second blocks being obtained by dividing the first target block), and the plurality of the second blocks are obtained by dividing the first target block (Fig. 16, Col. 21 lines 4-30, wherein performing coverage tests on a megaspan to obtain coverage data for a first triangle cluster, then determining a finer level of coverage by performing coverage tests on spans to obtain coverage data for a second triangle cluster, where the spans are subsections of the span, and coverage tests are performed for the same primitive, suggests that the second triangle cluster is a subset of the first triangle cluster).
Surti does not teach a plurality of first blocks of a camera view port, and rendering triangles in the second triangle cluster of a second target block to pixels in the second target block, the second target block being any one of the plurality of second blocks.
Laine teaches a plurality of first blocks of a camera view port (Section 4.1 paragraph 3; Section 5.1, wherein the viewport being divided into bins is interpreted as blocks of a camera viewpoint), and rendering triangles in the second triangle cluster of a second target block to pixels in the second target block, the second target block being any one of the plurality of second blocks (Fig. 1, section 5.4, wherein shading the associated tile’s framebuffer based on the triangles inputted for the tile is interpreted as rendering triangles to pixels in a second target block, wherein tiles are interpreted as a plurality of second blocks).
The motivation to combine would be the same as that set forth for claim 1.
7. Claims 15, 19 are rejected under 35 U.S.C. 103 as being unpatentable over Surti in view of Laine as applied to claims 1, 16 above, and further in view of Liu (Liu, Shichen, et al. "Soft rasterizer: A differentiable renderer for image-based 3d reasoning." Proceedings of the IEEE/CVF international conference on computer vision. 2019.), hereinafter Liu.
Regarding claim 15, Surti in view of Laine discloses the method of claim 1. Additionally, Liu teaches the method according to claim 1, wherein the method further comprises: computing an image difference between a first image rendered by the method and a second image, wherein the second image is obtained by rendering through an off-line renderer (Fig. 8, Section 4.1, providing a rendering-based error signal by comparing a rendered image with the ground truth, wherein the error signal is interpreted as an image difference between two images, and the ground truth is interpreted as being an image obtained by rendering through a separate off-line renderer); back propagating the image difference through a gradient of an error function to obtain updated fragment data of the plurality of triangles in a clip space, wherein the error function indicates a process of rendering the fragment data of the plurality of triangles to a two-dimensional image (Fig. 8, section 4.1-4.2, wherein pixel-level errors are back propagated through its gradient for the purposes of shape fitting, wherein the gradient is defined as a gradient from image pixels to shape and color generators which is interpreted as fragment data; Fig. 6, section 4.1, wherein the error function is part of the process for mesh reconstruction which is interpreted as indicating a process or rendering fragment data); and updating the first image based on the updated fragment data of the plurality of triangles (Fig. 8, section 4.2, wherein back propagating the gradient for the purposes of optimization is interpreted as updating the first image based on updated fragment data).
It would be obvious to one of ordinary skill before the effective filing date of the claimed invention to have modified Surti in view of Lain to incorporate the teachings of Liu for this method of backpropagating a gradient during the rasterization process. Surti discusses a hierarchical rasterization method in order to reduce the number of computations needed to perform rasterization by reducing redundant coverage testing. Similarly, Laine discusses a rasterization pipeline where triangles are processed and rasterized into bins, and then further rasterized into tiles, in order to save on bandwidth and memory, and to have the entire rasterization process be able to run on software only. Both of these references discuss rasterization techniques involving performing multiple coverage tests on subsections of an area, in order to perform rasterization more efficiently. Additionally, Liu introduces a novel, differentiable rasterization model, for the purposes of allowing 3D scene reconstruction from a rasterized 2D image. As the hierarchical, layered coverage testing in Surti and Laine would not conflict with the differentiable, soft rasterization detailed in Liu, it would be obvious to combine them to have both the benefits of reducing computations and saving memory, while allowing for generating a 2D rasterized image that can be reconstructed into a 3D scene.
Regarding claim 19, Surti in view of Laine discloses the device of claim 16. Additionally, Liu teaches the device according to claim 16, wherein the method further comprises: computing an image difference between a first image rendered by the method and a second image, wherein the second image is obtained by rendering through an off-line renderer (Fig. 8, Section 4.1, providing a rendering-based error signal by comparing a rendered image with the ground truth, wherein the error signal is interpreted as an image difference between two images, and the ground truth is interpreted as being an image obtained by rendering through a separate off-line renderer); back propagating the image difference through a gradient of an error function to obtain updated fragment data of the plurality of triangles in a clip space, wherein the error function indicates a process of rendering the fragment data of the plurality of triangles to a two-dimensional image (Fig. 8, section 4.1-4.2, wherein pixel-level errors are back propagated through its gradient for the purposes of shape fitting, wherein the gradient is defined as a gradient from image pixels to shape and color generators which is interpreted as fragment data; Fig. 6, section 4.1, wherein the error function is part of the process for mesh reconstruction which is interpreted as indicating a process or rendering fragment data); and updating the first image based on the updated fragment data of the plurality of triangles (Fig. 8, section 4.2, wherein back propagating the gradient for the purposes of optimization is interpreted as updating the first image based on updated fragment data).
Allowable Subject Matter
8. Claims 5, 6, 10 are objected to as being dependent upon a rejected base claim, but would be allowable if rewritten in independent form including all of the limitations of the base claim and any intervening claims.
Response to Arguments
9. Applicant's arguments filed November 12th, 2025 have been fully considered but they are not persuasive.
Applicant argues that Surti (US 10037621 B2), nor any combination with Laine or any other cited prior art does not distinguish between a first triangle cluster and a second triangle cluster, wherein the second triangle cluster is a subset of the first triangle cluster.
Examiner respectfully disagrees. Examiner replies that, during patent examination, the pending claims must be given their broadest reasonable interpretation consistent with the specification. See MPEP § 2111. Also, it is improper to import claim limitations from the specification. See MPEP § 2111.01(II).
Additionally, Examiner argues that Surti clearly shows, in Fig. 15 Col. 20 lines 54-63, that a coverage test for a given primitive is performed on a “megaspan” block, which consists of multiple “superspan” blocks and is interpreted as a plurality of first blocks. A second coverage test can be performed in parallel on all the superspans, which is interpreted as performing a second coverage test on all the first blocks, including any given first target block. Then, each first target block can also be further divided into “spans” and have additional coverage tests performed, which is interpreted as performing coverage tests on a plurality of second blocks of the first target block.
Furthermore, Surti teaches performing a coverage test on a first triangle cluster of a first target block. The rasterization process is defined on Col. 19 line 63 – Col. 20 line 3 as outputting a sequence of fragments that cover the shape of a given triangle, which is interpreted as a cluster of triangles. Given that, Fig. 16, Col. 21 lines 18-30 states that a superspan is traversed based on whether the megaspan is partially covered by a triangle or not. This is interpreted as performing the second coverage test on a first target block of a plurality of first blocks based on a first triangle cluster that intersected with the plurality of blocks. Additionally, Surti states that this process is repeated again, where given a partially covered superspan, another coverage test can be performed for a superspan divided into spans, as stated in Fig. 15, Col. 20 lines 59-63, and on Col. 21 lines 24-30. This is interpreted as a coverage test being performed on a plurality of second blocks of the first target block, to obtain coverage data of a second triangle cluster. This span is a subsection of superspan, and both coverage tests are performed on the same triangle, this suggests that the second triangle cluster would be a subset of the first triangle cluster, similar to how the plurality of second blocks are a subset of the first target block.
In conclusion, the rejections set forth in the previous Office Action are shown to have been proper, and the claims are rejected above. To the extent that new citations and parenthetical remarks can be considered new grounds of rejection, such new grounds are necessitated by applicant’s amendments to the claim. Therefore, the present office action is made final.
Conclusion
10. THIS ACTION IS MADE FINAL. Applicant is reminded of the extension of time policy as set forth in 37 CFR 1.136(a).
A shortened statutory period for reply to this final action is set to expire THREE MONTHS from the mailing date of this action. In the event a first reply is filed within TWO MONTHS of the mailing date of this final action and the advisory action is not mailed until after the end of the THREE-MONTH shortened statutory period, then the shortened statutory period will expire on the date the advisory action is mailed, and any nonprovisional extension fee (37 CFR 1.17(a)) pursuant to 37 CFR 1.136(a) will be calculated from the mailing date of the advisory action. In no event, however, will the statutory period for reply expire later than SIX MONTHS from the mailing date of this final action.
11. Any inquiry concerning this communication or earlier communications from the examiner should be directed to JORDAN W YICK whose telephone number is (571)272-4063. The examiner can normally be reached M-F 8-5.
Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice.
If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, Said Broome can be reached at (571) 272-2931. The fax phone number for the organization where this application or proceeding is assigned is 571-273-8300.
Information regarding the status of published or unpublished applications may be obtained from Patent Center. Unpublished application information in Patent Center is available to registered users. To file and manage patent submissions in Patent Center, visit: https://patentcenter.uspto.gov. Visit https://www.uspto.gov/patents/apply/patent-center for more information about Patent Center and https://www.uspto.gov/patents/docx for information about filing in DOCX format. For additional questions, contact the Electronic Business Center (EBC) at 866-217-9197 (toll-free). If you would like assistance from a USPTO Customer Service Representative, call 800-786-9199 (IN USA OR CANADA) or 571-272-1000.
/JORDAN WAN YICK/Examiner, Art Unit 2612
/Said Broome/Supervisory Patent Examiner, Art Unit 2612