DETAILED ACTION
Notice of Pre-AIA or AIA Status
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
Response to Amendment
This Office Action is in response to Applicant’s amendment/response filed on 07/29/2026, which has been entered and made of record. Applicant’s amendments to the Specification have overcome each and every objection previously set forth in the Non-Final Office Action mailed 05/01/2026.
Claim Rejections - 35 USC § 103
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.
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.
Claims 1 and 10 are rejected under 35 U.S.C. 103 as being unpatentable over Kleen et al. (US 20170309027 A1, hereinafter “Kleen”) in view of Archive_BVH (Bounding Volume Hierarchies, archive.org, https://web.archive.org/web/20221231175059/https://pbr-book.org/3ed-2018/Primitives_and_Intersection_Acceleration/Bounding_Volume_Hierarchies, hereinafter “Archive_BVH”).
Regarding claim 1, Kleen discloses A method of operating a tile-based graphics processor that is operable to generate a render output by processing primitives to generate rendering tiles that the render output is divided into;
the method comprising generating a render output by (page 1, para. [0001], “The technology described herein relates to a method of and apparatus for processing graphics, and in particular to such a method and apparatus for use in a tile-based graphics processing system … In tile-based rendering, the two-dimensional render output or target (i.e. the output of the rendering process, such as an output frame to be displayed) is rendered as a plurality of smaller area sub-regions, usually referred to as "tiles").
performing a first processing pass and performing a :
Wherein performing the first processing pass comprising:
, wherein bounding boxes of representative of positions of a set of primitives to be processed to generate the render output; and (page 1, para. [0009], “It is also known to prepare primitive-lists with a lower precision than is achieved with exact binning. This can be useful to, e.g., simplify the preparation of the primitive-lists. One common "less precise" binning technique is "bounding box" binning. In this case, a so-called "bounding box" is drawn around a primitive or a set of primitives, and then the tiles covered by the bounding box are determined”; page 14, para. [0201], “In step 303, the primitive list building unit 41 retrieves the transformed primitive position data from the programmable vertex shader 27 for a primitive to be processed. In step 304, the primitive list building unit 41 uses the transformed primitive position data to calculate a bounding box for the primitive.”). Note that: (1) a set of bounding boxes can be drawn around a primitive or a set of primitives; and (2) this process for generating a set of bounding boxes can be regarded as a first processing pass.
second processing
wherein performing the second processing pass comprises, for one or more rendering tiles that the render output is divided into: (page 1, para. [0003], In tile-based rendering, the two-dimensional render output or target (i.e. the output of the rendering process, such as an output frame to be displayed) is rendered as a plurality of smaller area sub-regions, usually referred to as "tiles". The tiles are each rendered separately (typically one-after-another). The rendered tiles are then recombined to provide the complete rendering output (e.g. frame for display)”). Note that: (1) the rendering tiles can be regarded as a second processing pass; and (2) the rendering output is recombined with the rendering tiles.
storing information representative of the hierarchy of bounding boxes for use in the second processing pass to determine which primitives of the set of primitives to process to generate a rendering tile; and (page 1, paras. [0009]-[0010], “The primitive or primitives that the bounding box represents (i.e. that are encompassed by the bounding box) are then listed (binned) for each tile that the bounding box has been found to cover (at least in part). Once lists of primitives to be rendered (primitive lists) have been prepared for each rendering tile in this way, the primitive-lists are stored for use, e.g., to allow the system to identify which primitives need to be considered (and rendered) when the tile in question is rendered.”). Note that: (1) the information of primitives and lists of primitives are stored or written out; (2) it is obvious to one having ordinary skill in the art that the information representative of the corresponding set of bounding boxes of the primitives can be stored or written-out in terms of bounding box positions and included primitives’ positions and vertexes; and (3) the stored information representative of the hierarchy of bounding boxes can us used for use in the second processing pass or for any applicable uses.
reading information representative of the hierarchy of bounding boxes stored in the first processing pass; Note that: since the information representative of the hierarchy of bounding boxes has been stored for use, it is obvious to one having ordinary skill in the art that the information can be read from the storage for use.
to determine which primitives of the set of primitives to process to generate the respective rendering tile; and (FIG. 2: “Generate bounding box for primitive 304”, “Determine which sub-region the bounding box falls within 305”. And “Add primitive to primitive lists corresponding to those sub-regions 306”; page 7, para. [0094], “Essentially the process will involve identifying, for each primitive to be processed for the render output, which sub-regions of the render output the primitive (potentially) falls in. Various techniques for sorting and binning primitives into tile-lists and render output regions or areas, such as exact binning, or bounding box binning, or anything in between, can be used for this process. In an embodiment bounding box binning is used”). Note that: bounding box binning with the information representative of the set of bounding boxes is used to determine primitives of the set of primitives to process to generate the respective rendering tile.
… determine which primitives of the set of primitives to process to generate a rendering tile …
processing the determined primitives to generate the respective rendering tile. (page 17, para. [0245], “The primitive selection unit 29 then chooses a next primitive to be rendered for the primitive list or lists that have been read for the rendering tile in question. Once a primitive has been selected, the primitive selection unit 29 passes that primitive to the vertex selection unit 31. The vertex selection unit 31 then retrieves the appropriate transformed geometry data for the vertices of the primitive in question from the transformed geometry data 25 stored in the memory 23, and provides that data to the rasterising unit 33. The primitive is then rasterised and rendered, and the resulting rendered primitive data stored appropriately in the tile buffers 35. This process is repeated for all the primitives that need to be rendered for a given rendering tile (i.e. that are included in primitive lists 26 appropriate to the tile) until all the primitives for the tile have been rendered (and so the tile buffers contain all the rendered data for the tile in question). The rendered tile data can then be written out (exported) to external memory, such as a frame buffer in main memory (not shown)”). Note that: (1) The primitive selection unit 29 chooses or determines that a next primitive of the set of primitives for processing; and (2) for each given rendering tile each primitive of the determined primitives is processed by repeating the way of selecting the primitive, retrieving the appropriate transformed geometry data, rasterizing, and rendering the primitive above.
However, Kleen fails to disclose, but in the same art of computer graphics, Archiv_BVH discloses
building a hierarchy of bounding boxes … the hierarchy of bounding boxes are (Archive_BVH, page 1, para. 2, “Bounding volume hierarchies (BVHs) are an approach for ray intersection acceleration based on primitive subdivision, where the primitives are partitioned into a hierarchy of disjoint sets. (In contrast, spatial subdivision generally partitions space into a hierarchy of disjoint sets.) Figure 4.2 shows a bounding volume hierarchy for a simple scene. Primitives are stored in the leaves, and each node
stores a bounding box of the primitives in the nodes beneath it. Thus, as a ray traverses through the tree, any time it doesn’t intersect a node’s bounds, the subtree beneath that node can be skipped.)”; page 2, para. 3, “There are three stages to BVH construction in the implementation here. First, bounding information about each primitive is computed and stored in an array that will be used during tree construction. Next, the tree is built using the algorithm choice encoded in splitMethod. The result is a binary tree where each interior node holds pointers to its children and each leaf node holds references to one or more primitives. Finally, this tree is converted to a more compact (and thus more efficient) pointerless representation for use during rendering.”). Note that: (1) Bounding Volume Hierarchies (BVH) are a representation of a hierarchy of bounding boxes in which the primitives are partitioned and stored; and (2) BVH(s) can be constructed or built following the three stages.
traversing the hierarchy of bounding boxes (Archive_BVH, page 19 / para 11 – page 20 / para. 11 “4.3.5 Traversal The BVH traversal code is quite simple—there are no recursive function calls and only a tiny amount of data to maintain about thecurrent state of the traversal. The Intersect() method starts by precomputing a few values related to the ray that will be … Each time the while loop in Intersect() starts an iteration, currentNodeIndex holds the offset into the nodes array of the node to be visited … At each node, we check to see if the ray intersects the node’s bounding box (or starts inside of it) … If the current node is a leaf, then the ray must be tested for intersection with the primitives inside it … For an interior node that the ray hits, it is necessary to visit both of its children … The BVHAccel::IntersectP() method is essentially the same as the regular intersection method, with the two differences thatPrimitive’s IntersectP() methods are called rather than Intersect(), and traversal stops immediately when any intersection is found.”). Note that: the method traversing the hierarchy of bounding boxes represented by the BVH with nodes and corresponding bounding boxes is described above.
Kleen and Archive_BVH are in the same field of endeavor, namely computer graphics. Before the effective filing date of the claimed invention, it would have been obvious to apply building a hierarchy of bounding boxes for one of more rendering tiles and traversing it to determine which primitives of the set of primitives to process, as taught by Archive_BVH into Kleen. The motivation would have been “BVHs are more efficient to build than kd-trees, which generally deliver slightly faster ray intersection tests than BVHs but take substantially longer to build. On the other hand, BVHs are generally more numerically robust and less prone to missed intersections due to round-off errors than kd-trees are.” (Hakura, page 1, para. [0008]). The suggestion for doing so would allow to build a hierarchy of bounding boxes more efficient and make the representation of the hierarchy more robust. Therefore, it would have been obvious to combine Kleen and Archive_BVH.
Claim 10 reciting “A tile-based graphics processor that is operable to generate a render output by processing primitives to generate rendering tiles that the render output is divided into; the tile-based graphics processor comprising:” is corresponding to the method claim 1. Therefore, claim 10 is rejected for the same rationale for claim 1.
In addition, Kleen in Archive_BVH discloses A tile-based graphics processor that is operable to generate a render output by processing primitives to generate rendering tiles that the render output is divided into; the tile-based graphics processor comprising: (Kleen, page 2, para. [0019], “FIG. 2 shows a tiling flow process that is used by the graphics processor of FIG. 1”; page 1, para. [0001], “The technology described herein relates to a method of and apparatus for processing graphics, and in particular to such a method and apparatus for use in a tile-based graphics processing system … In tile-based rendering, the two-dimensional render output or target (i.e. the output of the rendering process, such as an output frame to be displayed) is rendered as a plurality of smaller area sub-regions, usually referred to as "tiles").
The motivation to combine Kleen and Archive_BVH given in claim 1 is incorporated here.
Claims 2 and 11 are rejected under 35 U.S.C. 103 as being unpatentable over Kleen in view of Archive_BVH and Hakura et al. (US 9,612,839 B2, hereinafter “Hakura_2017”).
Regarding claim 2, Kleen in view of Archive_BVH discloses The method of claim 1, wherein the hierarchy of bounding boxes comprises:
a set of primitive bounding boxes, wherein each primitive bounding box of the set of primitive bounding boxes bounds a single primitive of the set of primitives; and (Archive_BVH, page 1, para. 2, “For a binary BVH that stores a single primitive in each leaf”). Note that: (1) when the hierarchy of bounding boxes is a binary BVH, the bounding box corresponding to each leaf node contains or bounds a single primitive of the set of primitives; (2) the corresponding bounding boxes for all leaf nodes of the BVH can be regarded as a set of primitive bounding boxes.
one or more sets of higher level bounding boxes, wherein each higher level bounding box of the one or more sets of higher level bounding boxes bounds plural primitive bounding boxes of the set of primitive bounding boxes; and (Archive_BVH, page 1, Figure 4.2: “Bounding Volume Hierarchy for a Simple Scene. (a) A small collection of primitives, with bounding boxes shown by dashed lines. The primitives are aggregated based on proximity; here, the sphere and the equilateral triangle are bounded by another bounding box before being bounded by a bounding box that encompasses the entire scene (both shown in solid lines). (b) The corresponding bounding volume hierarchy. The root node holds the bounds of the entire scene. Here, it has two children, one storing a bounding box that encompasses the sphere and equilateral triangle (that in turn has those primitives as its children) and the other storing the bounding box that holds the skinny triangle”, and “
PNG
media_image1.png
620
562
media_image1.png
Greyscale
”). Note that: each higher level bounding box corresponding to a non-leaf node of the BVH bounds or contains plural primitive bounding boxes of the set of primitive bounding boxes. The large bounding box bounds three primitives in Figure 4.2(a) above.
wherein traversing the hierarchy of bounding boxes comprises: traversing the hierarchy of bounding boxes (Archive_BVH, page 19 / para 11 – page 20 / para. 11 “4.3.5 Traversal The BVH traversal code is quite simple—there are no recursive function calls and only a tiny amount of data to maintain about thecurrent state of the traversal. The Intersect() method starts by precomputing a few values related to the ray that will be … Each time the while loop in Intersect() starts an iteration, currentNodeIndex holds the offset into the nodes array of the node to be visited … At each node, we check to see if the ray intersects the node’s bounding box (or starts inside of it) … If the current node is a leaf, then the ray must be tested for intersection with the primitives inside it … For an interior node that the ray hits, it is necessary to visit both of its children … The BVHAccel::IntersectP() method is essentially the same as the regular intersection method, with the two differences thatPrimitive’s IntersectP() methods are called rather than Intersect(), and traversal stops immediately when any intersection is found.”). Note that: the method traversing the hierarchy of bounding boxes represented by the BVH with nodes and corresponding bounding boxes is described above.
The motivation to combine Kleen and Archive_BVH given in claim 1 is incorporated here.
However, Kleen in view of Archive_BVH fails to disclose, but in the same art of computer graphics, Hakura_2017 discloses
testing a rendering tile against bounding boxes of the hierarchy of bounding boxes to determine whether the rendering tile overlaps the bounding boxes, and when it is determined that the rendering tile overlaps a primitive bounding box of the set of primitive bounding boxes that bounds a single primitive of the set of primitives:
determining that the single primitive is a primitive to process to generate the rendering tile. (Hakura_2017, col. 15, lines 36-51, “The first world-space pipeline 352 (0) and second world-space pipeline 352(1) each include a bounding box generator unit (not shown) that determines to which screen space pipeline-the first screen-space pipeline 354(0) or the second screen-space pipeline 354(1)-each primitive should be transmitted. To make this determination, the bounding box generator unit generates bounding boxes for each primitive, and compares the bounding boxes to raster tiles 420. If a bounding box associated with a primitive overlaps one or more raster tiles associated with a particular screen-space pipeline 354, then the bounding box generator unit determines that the primitive is to be transmitted to that screen-space pipeline 354. A primitive may be transmitted to multiple screen-space pipelines 354 if the primitive overlaps raster tiles 420 associated with more than one screen-space pipeline 354, then the bounding box generator unit determines that the primitive is to be transmitted to that screen-space pipeline 354”). Note that: (1) the bounding box generator unit generates bounding boxes and compares or tests the bounding boxes to raster tiles 420; (2) If a bounding box associated with a primitive overlaps one or more raster tiles associated with a particular screen-space pipeline 354, it is determine that the rendering tile overlaps the bounding boxes; and (3) when it is determine that the rendering tile overlaps the bounding boxes, since there is only one single primitive in each of the set of primitive bounding boxes, it is determined that the single primitive is the primitive to be transmitted and processed by that screen-space pipeline 354.
Kleen in view of Archive_BVH, and Hakura_2017, are in the same field of endeavor, namely computer graphics. Before the effective filing date of the claimed invention, it would have been obvious to apply testing a rendering tile against bounding boxes of the hierarchy of bounding boxes whether the rendering tile overlaps the bounding boxes and processing determining the single primitive for processing, as taught by Hakura_2017 into Kleen in view of Archive_BVH. The motivation would have been “If a bounding box associated with a primitive overlaps one or more raster tiles associated with a particular screen-space pipeline 354, then the bounding box generator unit determines that the primitive is to be transmitted to that screen-space pipeline 354.” (Hakura_2017, col. 15, lines 44-48). The suggestion for doing so would allow to determine whether the rendering tile overlaps the bounding boxes and the single primitive to process. Therefore, it would have been obvious to combine Kleen, Archive_BVH, and Hakura_2017.
Claim 11 is corresponding to the method of claim 2. Therefore, claim 11 is rejected for the same rationale for claim 2.
Claims 3-7, 12-16, and 18 are rejected under 35 U.S.C. 103 as being unpatentable over Kleen in view of Archive_BVH and Hakura et al. (US 20140118365, hereinafter “Hakura_2014”).
Regarding claim 3, Kleen in view Archive_BVH discloses The method of claim 1, wherein performing the first processing pass comprises:
However, Kleen in view Archive_BVH, but in the same art of computer graphics, Hakura_2014 discloses
assigning primitives of the set of primitives to one or more packets of one or more primitives;
storing the one or more packets; and
processing the one or more packets to generate the set of bounding boxes. (Hakura_2014, ABSTRACT, “each bounding box is associated with one or more graphics primitives being rendered to a render surface, and wherein the render surface is divided into the plurality of cache tiles”; page 11, para. [0114], “any number of accumulated bounding boxes may be combined to generate each coarse bounding box. In one implementation, each coarse bounding box may include approximately 128 graphics primitives. Thus, if it is assumed that each accumulated bounding box includes approximately eight graphics primitives, then approximately 16 accumulated bounding boxes would be combined to generate each coarse bounding box. One example of this type of bounding box hierarchy is shown in FIG. 11, which is a conceptual illustration showing the relationship between a coarse bounding box 1110-2 and multiple accumulated bounding boxes 620, according to one embodiment of the present invention”; page 10, para. [0107]), “FIG. 9B is a conceptual illustration showing how a global bounding box 910 is generated from the accumulated bounding boxes of FIG. 9A, according to one embodiment of the present invention. During tiled rendering, if the array indicates that one or more accumulated bounding boxes stored in the buffer memory intersect a particular cache tile 410, the tiling unit 375 then further determines whether the global bounding box 910 intersects the cache tile 410. As shown in FIG. 9B, if the global bounding box 910 does not intersect the cache tile 410, then the cache tile 410 is empty.”; FIG. 9B: iteratively accumulating bounding boxes with the corresponding primitives’ positions, “910” as a packet bounding box bounding primitive bounding boxes “620-7”, “620-8”, and “620-9”). Note that: (1) a bounding box hierarchy is built as a representation of the set of bounding boxes while each bounding box is associated with one or more graphics primitives being rendered to the rendering tile; (2) a primitive bounding box can be drawn around each primitive of all primitives; (3) lower level bounding boxes including primitive bounding boxes can be accumulated or assigned as one or more packets or pocket bounding boxes at higher levels; (4) one or more pocket bounding boxes at higher levels can be accumulated or assigned as a root bounding box; (5) the root, packet, and primitive bounding boxes at different levels form the set of bounding boxes; and (6) during the assigning primitives to the packets and processing of the packets, it is obvious to one having ordinary skill in the art that the packets as data are stored in the storage (e.g., Memory, RAM) for writing and/or reading.
Kleen and Hakura_2014 are in the same field of endeavor, namely computer graphics. Before the effective filing date of the claimed invention, it would have been obvious to apply building and using a bounding box hierarchy for one of more rending tiles, as taught by Hakura_2014 into Kleen in view of Archive_BVH. The motivation would have been “reduce the amount of data transmitted over a crossbar and increase the efficiency of tiling operations in a parallel tile-based architecture” (Hakura_2014, page 1, para. [0008]). The suggestion for doing so would allow to reduce the amount of data transmutation and improve the efficiency of tiling operations. Therefore, it would have been obvious to combine Kleen, Archive_BVH, and Hakura_2014.
Regarding claim 4, the combination of Kleen, Archive_BVH, and Hakura_2014 discloses The method of claim 3, wherein processing the one or more packets to build the hierarchy of bounding boxes comprises:
Generating and storing, for each primitive of a packet, a primitive bounding box that bounds the respective primitive; and
Generating and storing, for each packet, a packet bounding box that bounds all of the one or more primitives of the respective packet. (Hakura_2014, ABSTRACT, “each bounding box is associated with one or more graphics primitives being rendered to a render surface, and wherein the render surface is divided into the plurality of cache tiles”; page 11, para. [0114], “any number of accumulated bounding boxes may be combined to generate each coarse bounding box. In one implementation, each coarse bounding box may include approximately 128 graphics primitives. Thus, if it is assumed that each accumulated bounding box includes approximately eight graphics primitives, then approximately 16 accumulated bounding boxes would be combined to generate each coarse bounding box. One example of this type of bounding box hierarchy is shown in FIG. 11, which is a conceptual illustration showing the relationship between a coarse bounding box 1110-2 and multiple accumulated bounding boxes 620, according to one embodiment of the present invention”; page 10, para. [0107]), “FIG. 9B is a conceptual illustration showing how a global bounding box 910 is generated from the accumulated bounding boxes of FIG. 9A, according to one embodiment of the present invention. During tiled rendering, if the array indicates that one or more accumulated bounding boxes stored in the buffer memory intersect a particular cache tile 410, the tiling unit 375 then further determines whether the global bounding box 910 intersects the cache tile 410. As shown in FIG. 9B, if the global bounding box 910 does not intersect the cache tile 410, then the cache tile 410 is empty.”; FIG. 9B: iteratively accumulating bounding boxes with the corresponding primitives’ positions, “910” as a packet bounding box bounding primitive packet or primitive bounding boxes “620-7”, “620-8”, and “620-9”). Note that: (1) a primitive bounding box can be drawn around or generated for each primitive of a packet (e.g., the packet of primitives contained in the packet bounding box “620-7”); (2) a packet bounding box (e.g., “620-7”) for the packet of the primitives is generated for each packet corresponding to “620-7”, “620-8”, and “620-9”; and (3) during generating the primitive bound box and the packet bounding box, it is obvious to one having ordinary skill in the art that the primitive bound box and the packet bounding box as data are stored in the storage (e.g., Memory, RAM) for writing and/or reading.
The motivation to combine Kleen, Archive_BVH and Hakura_2014 given in claim 3 is incorporated here.
Regarding claim 5, the combination of Kleen, Archive_BVH, and Hakura_2014 discloses The method of claim 4, wherein processing the one or more packets to build the hierarchy of bounding boxes further comprises generating and storing, for one or more sets of plural packets, a respective higher-level bounding box that bounds all of the primitives of the plural packets of the respective set of plural packets. (Hakura_2014, page 11, para. [0114], “any number of accumulated bounding boxes may be combined to generate each coarse bounding box. In one implementation, each coarse bounding box may include approximately 128 graphics primitives. Thus, if it is assumed that each accumulated bounding box includes approximately eight graphics primitives, then approximately 16 accumulated bounding boxes would be combined to generate each coarse bounding box. One example of this type of bounding box hierarchy is shown in FIG. 11, which is a conceptual illustration showing the relationship between a coarse bounding box 1110-2 and multiple accumulated bounding boxes 620, according to one embodiment of the present invention”; page 10, para. [0107]), “FIG. 9B is a conceptual illustration showing how a global bounding box 910 is generated from the accumulated bounding boxes of FIG. 9A, according to one embodiment of the present invention. During tiled rendering, if the array indicates that one or more accumulated bounding boxes stored in the buffer memory intersect a particular cache tile 410, the tiling unit 375 then further determines whether the global bounding box 910 intersects the cache tile 410. As shown in FIG. 9B, if the global bounding box 910 does not intersect the cache tile 410, then the cache tile 410 is empty.”; FIG. 9B: iteratively accumulating bounding boxes with the corresponding primitives’ positions, “910” as a packet bounding box bounding primitive pocket or primitive bounding boxes “620-7”, “620-8”, and “620-9”). Note that: (1) one or more packets (the packets corresponding to “620-7”, “620-8”, and “620-9”) can be processed or accumulated to generate a higher level bounding box as a root bounding box; (2) the root, packet, and primitive bounding boxes at different levels form the set of bounding boxes; and (3) during generating the higher-level bounding box, it is obvious to one having ordinary skill in the art that the higher-level bounding box as data are stored in the storage (e.g., Memory, RAM) for writing and/or reading.
The motivation to combine Kleen, Archive_BVH, and Hakura_2014 given in claim 3 is incorporated here.
Regarding claim 6, the combination of Kleen, Archive_BVH, and Hakura_2014 discloses The method of claim 3, wherein performing the first processing pass comprises storing information indicating an order in which packets were generated, and performing the second processing pass comprises using the information so as to process primitives in accordance with the order in which packets were generated. (Kleen, page 16, para. [0238], “the primitive list building unit 28 places the primitives in the primitive lists 26 in the order that it receives the primitives from the programmable vertex shader 27. This means that, so far as each individual primitive list 26 is concerned, the primitives in the list are in the order that they were generated, which will typically correspond to the desired order of rendering the primitives”). Note that: (1) the order to place the primitives in the primitive list can be regarded as the information representative of the set of bounding boxes to be stored in the first processing pass; and (2) since each packet of the packets includes plural primitives in corresponding order when the packet was generated and is corresponding to a primitive list, it is obvious to one having ordinary skills in the art that the same order of primitives in a packet stored in the first processing pass can be used to process the corresponding packet in the second processing pass.
Regarding claim 7, the combination of Kleen, Archive_BVH, and Hakura_2014 discloses The method of claim 3, comprising processing plural packets at the same time to build the hierarchy of bounding boxes. (Kleen, page 11, para. [0155], “When there is more than a single primitive list to checked for a single rendering tile, in an embodiment all of those primitive lists are provided to the primitive selection unit in parallel (i.e. simultaneously), with the primitive selection unit then selecting the next primitive to process from one of the lists.”). Note that: (1) plural packets are corresponding to the determined primitive lists; (2) since the primitive lists can be fed to the primitive selection unit in parallel, it is obvious to one having ordinary skills in the art that plural packets can be processed or handled simultaneously; and (3) plural packets can be the bounding boxes at different levels of the hierarchy of bounding boxes (BVH).
Claims 12-16 are corresponding to the method of claims 3-7, respectively. Therefore, claims 12-16 are rejected for the same rationale for claims 3-7, respectively.
Regarding claim 18, Kleen, Archive_BVH, and Hakura_2014 disclose The method of claim 4, wherein performing the first processing pass comprises:
storing primitive bounding boxes in the one or more packets; and (Hakura_2014, FIG. 9B: iteratively accumulating bounding boxes with the corresponding primitives’ positions, “910” as a packet bounding box bounding primitive packet or primitive bounding boxes “620-7”, “620-8”, and “620-9”). Note that: packet “910” stores primitive bounding boxes “620-7”, “620-8”, and “620-9”.
wherein traversing the hierarchy of bounding boxes comprises:
testing a rendering tile against bounding boxes of the hierarchy of bounding boxes to determine whether the rendering tile overlaps the bounding boxes, and when it is determined that the rendering tile overlaps a packet bounding box that bounds all of the primitives of a packet:
testing the rendering tile against bounding boxes stored in the packet. (Hakura_2014, para. [0107], “FIG. 9B is a conceptual illustration showing how a global bounding box 910 is generated from the accumulated bounding boxes of FIG. 9A, according to one embodiment of the present invention. During tiled rendering, if the array indicates that one or more accumulated bounding boxes stored in the buffer memory intersect a particular cache tile 410, the tiling unit 375 then further determines whether the global bounding box 910 intersects the cache tile 410. As shown in FIG. 9B, if the global bounding box 910 does not intersect the cache tile 410, then the cache tile 410 is empty. If the global bounding box 910 intersects the cache tile 410, then one or more accumulated bounding boxes stored in the buffer memory may (or may not) intersect the cache tile 410.”) Note that: (1) the global bounding box 910 is regarded as a packet bounding box that bounds primitive bounding boxes “620-7”, “620-8”, and “620-9”; (2) the packet bounding box (910) is tested with the cache tile 410 to determine whether the global bounding box 910 intersects or overlaps the cache tile 410; (3) if it is determined that the global bounding box 910 intersects or overlaps the cache tile 410, the primitive bounding boxes “620-7”, “620-8”, and “620-9” stored in the global bounding box 910 can be taken as packets for test; and (4) in the same way for testing the global bounding box 910, the primitive bounding boxes “620-7”, “620-8”, and “620-9” as the packets are test to determine whether they intersect or overlap the cache tile 410, respectively.
The motivation to combine Kleen, Archive_BVH and Hakura_2014 given in claim 3 is incorporated here.
Claims 8-9 and 17 are rejected under 35 U.S.C. 103 as being unpatentable over Kleen in view of Hakura_2014.
Regarding claim 8, Kleen discloses A method of operating a tile-based graphics processor that is operable to generate a render output by processing primitives to generate rendering tiles that the render output is divided into;
the method comprising generating a render output by (page 1, para. [0001], “The technology described herein relates to a method of and apparatus for processing graphics, and in particular to such a method and apparatus for use in a tile-based graphics processing system … In tile-based rendering, the two-dimensional render output or target (i.e. the output of the rendering process, such as an output frame to be displayed) is rendered as a plurality of smaller area sub-regions, usually referred to as "tiles").
… second processing … in the second processing pass to determine which primitives of the set of primitives to process (FIG. 2: “Generate bounding box for primitive 304”, “Determine which sub-region the bounding box falls within 305”. And “Add primitive to primitive lists corresponding to those sub-regions 306”; page 7, para. [0094], “Essentially the process will involve identifying, for each primitive to be processed for the render output, which sub-regions of the render output the primitive (potentially) falls in. Various techniques for sorting and binning primitives into tile-lists and render output regions or areas, such as exact binning, or bounding box binning, or anything in between, can be used for this process. In an embodiment bounding box binning is used”). Note that: bounding box binning with the information representative of the set of bounding boxes is used to determine primitives of the set of primitives to process to generate the respective rendering tile. This process can be regarded as a second processing pass. to generate a rendering tile of the plural rendering tiles. (page 17, para. [0245], “The primitive selection unit 29 then chooses a next primitive to be rendered for the primitive list or lists that have been read for the rendering tile in question. Once a primitive has been selected, the primitive selection unit 29 passes that primitive to the vertex selection unit 31. The vertex selection unit 31 then retrieves the appropriate transformed geometry data for the vertices of the primitive in question from the transformed geometry data 25 stored in the memory 23, and provides that data to the rasterising unit 33. The primitive is then rasterised and rendered, and the resulting rendered primitive data stored appropriately in the tile buffers 35. This process is repeated for all the primitives that need to be rendered for a given rendering tile (i.e. that are included in primitive lists 26 appropriate to the tile) until all the primitives for the tile have been rendered (and so the tile buffers contain all the rendered data for the tile in question). The rendered tile data can then be written out (exported) to external memory, such as a frame buffer in main memory (not shown)”). Note that: for each given rendering tile each primitive of the determined primitives is processed by repeating the way of selecting the primitive, retrieving the appropriate transformed geometry data, rasterizing, and rendering the primitive above.
However, Kleen fails to disclose, but in the same art of computer graphics, Hakura discloses … performing first and second processing passes to generate plural rendering tiles that the render output is divided into, and when performing the first processing pass:
building a hierarchy of bounding boxes, wherein bounding boxes of the hierarchy of bounding boxes are representative of positions of a set of primitives to be processed to generate the render output; and (Hakura_2014, ABSTRACT, “each bounding box is associated with one or more graphics primitives being rendered to a render surface, and wherein the render surface is divided into the plurality of cache tiles”; page 11, para. [0114], “any number of accumulated bounding boxes may be combined to generate each coarse bounding box. In one implementation, each coarse bounding box may include approximately 128 graphics primitives. Thus, if it is assumed that each accumulated bounding box includes approximately eight graphics primitives, then approximately 16 accumulated bounding boxes would be combined to generate each coarse bounding box. One example of this type of bounding box hierarchy is shown in FIG. 11, which is a conceptual illustration showing the relationship between a coarse bounding box 1110-2 and multiple accumulated bounding boxes 620, according to one embodiment of the present invention”; page 10, para. [0107]), “FIG. 9B is a conceptual illustration showing how a global bounding box 910 is generated from the accumulated bounding boxes of FIG. 9A, according to one embodiment of the present invention. During tiled rendering, if the array indicates that one or more accumulated bounding boxes stored in the buffer memory intersect a particular cache tile 410, the tiling unit 375 then further determines whether the global bounding box 910 intersects the cache tile 410. As shown in FIG. 9B, if the global bounding box 910 does not intersect the cache tile 410, then the cache tile 410 is empty.”; FIG. 9B: iteratively accumulating bounding boxes with the corresponding primitives’ positions, “910” as a packet bounding box bounding primitive bounding boxes “620-7”, “620-8”, and “620-9”). Note that: (1) a bounding box hierarchy is built as a representation of the set of bounding boxes while each bounding box is associated with one or more graphics primitives being rendered to the rendering tile; (2) the tiling unit 375 can traverse the bounding box hierarchy to determine whether the global bounding box 910 and lower one or more accumulated bounding boxes stored in the buffer memory intersect a particular cache tile 410; and (3) building a hierarchy of bounding boxes can be regarded as a first processing pass to generate plural rendering tiles that the render output is divided into.
storing information representative of the hierarchy of bounding boxes for use Note that: it is obvious to one having ordinary skill in the art that the information representative of the generated hierarchy of bounding boxes can be stored or written out.
Kleen and Hakura_2014 are in the same field of endeavor, namely computer graphics. Before the effective filing date of the claimed invention, it would have been obvious to apply building and using a bounding box hierarchy for one of more rending tiles, as taught by Hakura_2014 into Kleen. The motivation would have been “reduce the amount of data transmitted over a crossbar and increase the efficiency of tiling operations in a parallel tile-based architecture” (Hakura_2014, page 1, para. [0008]). The suggestion for doing so would allow to reduce the amount of data transmutation and improve the efficiency of tiling operations. Therefore, it would have been obvious to combine Kleen and Hakura_2014.
Claim 9 reciting “A non-transitory computer readable storage medium storing software code which when executing on a processor” is corresponding to the method of claim 8. Therefore, claim 9 is rejected for the same rationale for claim 8.
In addition, Klee in view of Hakura_2014 discloses (Kleen, page 13, para. [0179], “The technology described herein may accordingly suitably be embodied as a computer program product for use with a computer system. Such an implementation may comprise a series of computer readable instructions either fixed on a tangible medium, such as a non-transitory computer readable medium, for example, diskette, CD ROM, ROM, RAM, flash memory, or hard disk.”; page 19, claim 20, “A computer readable storage medium storing computer software code which when executing on a processor
performs a method”). Note that: the computer readable storage medium storing computer software code can be as a non-transitory computer readable medium while executing the instructions on a processor.
Regarding claim 17, Kleen discloses A tile-based graphics processor that is operable to generate a render output by processing primitives to generate rendering tiles that the render output is divided into;
the graphics processor comprising: (page 1, para. [0001], “The technology described herein relates to a method of and apparatus for processing graphics, and in particular to such a method and apparatus for use in a tile-based graphics processing system … In tile-based rendering, the two-dimensional render output or target (i.e. the output of the rendering process, such as an output frame to be displayed) is rendered as a plurality of smaller area sub-regions, usually referred to as "tiles"). Note that: the apparatus for processing graphics is a graphics processor.
a rendering circuit operable to process primitives to generate a rendering tile; and … wherein the rendering circuit operable to process primitives provided by the primitive providing circuit to generate a rendering tile. (FIG. 1: “Render” with the corresponding graphics processor as a rendering circuit; FIG. 2: “Generate bounding box for primitive 304”, “Determine which sub-region the bounding box falls within 305”. And “Add primitive to primitive lists corresponding to those sub-regions 306”; page 7, para. [0094], “Essentially the process will involve identifying, for each primitive to be processed for the render output, which sub-regions of the render output the primitive (potentially) falls in. Various techniques for sorting and binning primitives into tile-lists and render output regions or areas, such as exact binning, or bounding box binning, or anything in between, can be used for this process. In an embodiment bounding box binning is used”; para. [0245], “The primitive selection unit 29 then chooses a next primitive to be rendered for the primitive list or lists that have been read for the rendering tile in question. Once a primitive has been selected, the primitive selection unit 29 passes that primitive to the vertex selection unit 31. The vertex selection unit 31 then retrieves the appropriate transformed geometry data for the vertices of the primitive in question from the transformed geometry data 25 stored in the memory 23, and provides that data to the rasterising unit 33. The primitive is then rasterised and rendered, and the resulting rendered primitive data stored appropriately in the tile buffers 35. This process is repeated for all the primitives that need to be rendered for a given rendering tile (i.e. that are included in primitive lists 26 appropriate to the tile) until all the primitives for the tile have been rendered (and so the tile buffers contain all the rendered data for the tile in question). The rendered tile data can then be written out (exported) to external memory, such as a frame buffer in main memory (not shown)”). Note that: (1) bounding box binning with the information representative of the set of bounding boxes is used to determine primitives of the set of primitives to process to generate the respective rendering tile; and (2) for each given rendering tile each primitive of the determined primitives is processed by repeating the way of selecting the primitive, retrieving the appropriate transformed geometry data, rasterizing, and rendering the primitive above.
However, Kleen fails to disclose, but in the same art of computer graphics, Hakura_2014 discloses
a primitive providing circuit operable to: (Hakura_2014, page 11, para. [0111], “During tiled rendering, the tiling unit 375 determines whether each accumulated bounding box stored in the buffer memory intersects a particular cache tile 410”; FIG. 3B: “Tiling Unit 375” in “Graphics Processing Pipeline 350” as a primitive providing circuit).
read information representative of a hierarchy of bounding boxes, wherein bounding boxes of the hierarchy of bounding boxes are representative of positions of a set of primitives to be processed to generate a render output; and (Hakura_2014, ABSTRACT, “each bounding box is associated with one or more graphics primitives being rendered to a render surface, and wherein the render surface is divided into the plurality of cache tiles”; page 11, para. [0114], “any number of accumulated bounding boxes may be combined to generate each coarse bounding box. In one implementation, each coarse bounding box may include approximately 128 graphics primitives. Thus, if it is assumed that each accumulated bounding box includes approximately eight graphics primitives, then approximately 16 accumulated bounding boxes would be combined to generate each coarse bounding box. One example of this type of bounding box hierarchy is shown in FIG. 11, which is a conceptual illustration showing the relationship between a coarse bounding box 1110-2 and multiple accumulated bounding boxes 620, according to one embodiment of the present invention”; page 10, para. [0107]), “FIG. 9B is a conceptual illustration showing how a global bounding box 910 is generated from the accumulated bounding boxes of FIG. 9A, according to one embodiment of the present invention. During tiled rendering, if the array indicates that one or more accumulated bounding boxes stored in the buffer memory intersect a particular cache tile 410, the tiling unit 375 then further determines whether the global bounding box 910 intersects the cache tile 410. As shown in FIG. 9B, if the global bounding box 910 does not intersect the cache tile 410, then the cache tile 410 is empty.”; FIG. 9B: iteratively accumulating bounding boxes with the corresponding primitives’ positions, “910” as a packet bounding box bounding primitive bounding boxes “620-7”, “620-8”, and “620-9”). Note that: (1) a bounding box hierarchy is built as a representation of the set of bounding boxes while each bounding box is associated with one or more graphics primitives being rendered to the rendering tile; and (2) it is obvious to one having ordinary skill in the art that: after the bounding box hierarchy have been build, the information representative of a hierarchy of bounding boxes including the information of the positions of the set of primitives can be read or written out for access to generate a render output.
traverse the hierarchy of bounding boxes to determine which primitives of the set of primitives to process to generate a rendering tile of plural rendering tiles that the render output is divided into; and
provide the determined primitives to the rendering circuit; (Hakura_2014, para. [0108], “At step 840, the tiling unit 375 determines whether an additional accumulated bounding box has been received from the world space pipeline 352. If an additional accumulated bounding box has been received, then steps 810, 820 and 830 are repeated. If an additional accumulated bounding box is not received, then the tiling unit 375 begins the process of tiled rendering at step 850 by identifying a cache tile 410 for which the accumulated bounding boxes and graphics primitives currently stored in the buffer memory are to be processed”; FIG. 9B: iteratively accumulating bounding boxes with the corresponding primitives’ positions, “910” as a packet bounding box bounding primitive bounding boxes “620-7”, “620-8”, and “620-9”). Note that: (1) the tiling unit 375 can traverse the bounding box hierarchy to determine whether the global bounding box 910 and lower one or more accumulated bounding boxes stored in the buffer memory intersect a particular cache tile 410; (2) If the global bounding box 910 intersect a particular cache tile 410, the tiling unit 375 determines if primitive bounding boxes “620-7”, “620-8”, and “620-9” intersects a particular cache tile 410, respectively; and (3) if it is determined a primitive intersects particular cache tile 410, the primitive is provided to the render by Kleen above.
The rationale to combine Kleen and Hakura_2014 given in claim 8 is incorporated here.
Response to Arguments
Applicant's arguments have been fully considered but they are not persuasive.
Applicant alleges, “Hence, one of average skill in the art would not be led by the combined teachings of Kleen and Hakura to find the subject matter of claim 1 obvious. Independent claim 10 includes similar features. For at least similar reasons to those discussed above with reference to independent claim 1, Applicant respectfully asserts that the applied references, alone or in combination, do not teach or suggest these features. Accordingly, Applicant respectfully requests reconsideration and withdrawal of the rejection of claim 10 under 35 U.S.C. §103.” (page 11, lines 10-15). However, Examiner respectfully disagrees about the respective allegations as whole because: (1) new reference Archive_BVH discloses building a hierarchy of bounding boxes and traversing the hierarchy of bounding boxes; (2) a motivation to combine Kleen and Archive_BVH has been formulated to discloses all limitations of claim 1. Please see the detailed recitations, explanations, and the corresponding rationale above; and (3) independent claim 10 corresponds to claim 1. Therefore, claim 10 is rejected for the same rationale for claim 1. The arguments are not persuasive.
Applicant alleges, “Dependent claims 2-9 and 11-17 depend from and add additional features to independent claim 1 and independent claim 10. Applicant respectfully asserts that these claims are patentable over the applied references for at least the reason that they depend from independent claim 1 and independent claim 10, as well as for the features that they add.” (page 11, lines 19-22). However, Examiner respectfully disagrees about the respective allegations as whole because: claims 2-9 and 11-17 are rejected for the respective rationale above. Please see the detailed citations, explanations, and rationales above. The arguments are not persuasive.
Conclusion
Applicant's amendment necessitated the new ground(s) of rejection presented in this Office action. Accordingly, THIS ACTION IS MADE FINAL. See MPEP § 706.07(a). 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.
Any inquiry concerning this communication or earlier communications from the examiner should be directed to BIAO CHEN whose telephone number is (703)756-1199. The examiner can normally be reached M-F 8am-5pm ET.
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, Kee M Tung can be reached at (571)272-7794. 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.
/Biao Chen/
Patent Examiner, Art Unit 2611
/KEE M TUNG/ Supervisory Patent Examiner, Art Unit 2611
Prosecution Insights