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 .
Claim Rejections - 35 USC § 112
The following is a quotation of the first paragraph of 35 U.S.C. 112(a):
(a) IN GENERAL.—The specification shall contain a written description of the invention, and of the manner and process of making and using it, in such full, clear, concise, and exact terms as to enable any person skilled in the art to which it pertains, or with which it is most nearly connected, to make and use the same, and shall set forth the best mode contemplated by the inventor or joint inventor of carrying out the invention.
The following is a quotation of the first paragraph of pre-AIA 35 U.S.C. 112:
The specification shall contain a written description of the invention, and of the manner and process of making and using it, in such full, clear, concise, and exact terms as to enable any person skilled in the art to which it pertains, or with which it is most nearly connected, to make and use the same, and shall set forth the best mode contemplated by the inventor of carrying out his invention.
Independent claims 1, 9 and 16 and dependent claims 2, 10-14 and 17 are rejected under 35 U.S.C. 112(a) or 35 U.S.C. 112 (pre-AIA ), first paragraph, as failing to comply with the written description requirement. The claim(s) contains subject matter which was not described in the specification in such a way as to reasonably convey to one skilled in the relevant art that the inventor or a joint inventor, or for applications subject to pre-AIA 35 U.S.C. 112, the inventor(s), at the time the application was filed, had possession of the claimed invention. The Specification discloses:
[0027] – “Based on the comparison of the depth value of the pixel to the predetermined threshold values, AU 114 then culls the pixel from the Z-buffer, or both by, for example, not storing the pixel attribute data or pixel depth data in the G-buffer or Z-buffer, respectively.”
[0009] – “... an attribute shader performs attribute computations on a deferred post-culling basis.”
[0012] – “... the AU leverages one or more shader engines to perform initial culling of primitives that are not relevant to (e.g., not visible in) the frame being rendered, to generate attribute data and geometric data for subsequent processing, and to perform subsequent attribute shading operations based on the culled processed geometric data.”
[0014] – “To implement a TIBR graphics pipeline, a processing system includes an acceleration unit (AU) configured to receive a command stream from an application being executed by the processing system. Such a command stream, for example, includes data indicating the primitives to be rendered for each frame of a series of frames... the AU first partitions the frame to be rendered into two or more tiles based on a geometry state indicated in the command stream...”
[0015] – “... the AU renders the primitives at least partially visible in the first tile into a geometry buffer (G-buffer)... the AU determines pixel attribute data indicating the position and color of the pixels of the primitives at least partially visible in the first tile.”
[0023] – “AU 114 first partitions a frame to be rendered into two or more tiles (e.g., coarse tiles).”
[0026] – “Based on the first pixel state 125, AU 114 then assembles, rasterizes, and shades the primitives using the per-tile geometry data 105 to produce per-tile pixel attribute data that is stored in the G-buffer and per-tile pixel depth data that is stored in a depth buffer...”
According to the Specification the Acceleration Unit (AU), performs the functions of amended independent claims 1, 9 and 16 and dependent claims 11-14: receiving primitives, culling primitives, generating attribute data, rasterizing primitives, dividing a frame, render a scene. There is no support in the Specification for “a shader” to perform all of these operations as recited in claim 1. Therefore these amended limitations of independent claims 1, 9, 16 and dependent claims 1-14 are considered to be NEW MATTER.
For claims 2, 10 and 17, the Specification discloses in [0009], “The primitive mesh shader handles the geometry of primitives by performing operations such as vertex pulling from vertex buffers and mesh shading, generating intermediate data for high-level geometry processing but stopping short of generating resource-intensive attribute data.”
Claim 2 recites, that the same shader of claim 1, that generates attribute data, also generates intermediate data. According to the Specification, the primitive mesh shader generates intermediate data, but does not generate attribute data. Thus, the Specification directly contradicts, for example, claims 1 and 2, which recite that the same shader generates attribute data and intermediate data. There is no support for the same shader performing these operations. Therefore, amended claims, 2, 10 and 17 are considered to be NEW MATTER.
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.
The factual inquiries for establishing a background for determining obviousness under 35 U.S.C. 103 are summarized as follows:
1. Determining the scope and contents of the prior art.
2. Ascertaining the differences between the prior art and the claims at issue.
3. Resolving the level of ordinary skill in the pertinent art.
4. Considering objective evidence present in the application indicating obviousness or nonobviousness.
Claim(s) 1, 9, 16; 2, 5, 7, 8, 10, 13, 15, 17 and 20 is/are rejected under 35 U.S.C. 103 as being unpatentable over Favela et al. U.S. Pub. No. 2020/0193703 in view of Zhu U.S. Patent No. 7,170,515 and Nordlund et al. U.S. Pub. No. 2013/0021358.
Re: claims 1, 9 and 16 (which are rejected under the same rationale), Favela teaches
1. (Currently Amended) A method comprising: receiving, by a shader engine , a set of primitives for rendering at least a portion of a scene; (“Figs. 1-4 disclose systems and techniques to improve the efficiency of graphics processing pipelines... a method of deferred vertex attributes shading includes computing, at a graphics processing pipeline of a graphics processing unit (GPU), a plurality of vertex attributes for vertices of each primitive... of a set of primitives. Geometry data includes graphics data items which describe geometry to be rendered. For example, the graphics data items represent geometric shapes, which describe surfaces of structures in the scene and which are referred to as “primitives”... Scenes typically contain many objects, with objects are composed of one or more such primitives (e.g., objects can be composed of many thousands, or even millions of such primitives.”; Favela, [0008])
The graphics processing pipeline computes plural vertex attributes for vertices of each primitive of the set of primitives received. The primitives describe surfaces of structures in a scene (receiving... a set of primitives for rendering a portion of a scene).
(“Fig. 3 is a block diagram illustrating a graphics processing pipeline 300 utilizing deferred vertex attribute shading... The graphics processing pipeline 300 includes at least a plurality of deferred attribute shading stages 302... the plurality of deferred attribute shading stages are implemented partially or fully as shader programs that execute at the processing cores 122 of Fig. 1.”; Favela, [0041], Fig. 3)
Fig. 3 illustrates a graphics pipeline that includes deferred attribute shading stages 302 that are implemented as shader programs that execute at the processing cores (one or more shader engines).
(“The plurality of deferred attribute shading stages 302 includes a vertex execution mask stage 304, a vertex fetch stage 306, a position calculation stage 308, a non-deferred parameter calculations stage 310, a primitive execution mask stage 312, a geometry shader operations stage 314, a culling stage 316, and a deferred parameter calculations stage 318... “For primitive related work (e.g., the geometry shader operations stage 314 and the culling stage 316), each work-item works on a primitive... Geometry shader programs typically accept whole primitives... as input and perform operations on those whole primitives as specified by the instructions of the geometry shader programs.”; Favela, [0042], [0043], [0049], Fig. 3)
Fig. 3 illustrates that the deferred attribute shading stages include, for example, a geometry shader operations stage 314 that accept whole primitives as input (receiving, by one or more shader engines, a set of primitives for rendering a portion of a scene).
culling the set of primitives by the shader engine , wherein culling the set of primitives comprises identifying a subset of the primitives that are potentially visible in the scene; (“The graphics processing pipeline 300 includes at least a plurality of deferred attribute shading stages 302... The plurality of deferred attribute shading stages 302 are implemented partially or fully as shader programs that execute at the processing cores of Fig. 1... The plurality of deferred attribute shading stages 302 includes... a culling stage 316...”; Favela, [0041], [0042], Fig. 3)
Fig. 3 illustrates a culling stage that is implemented as shader programs (culling... by the one or more shader engines).
(“The culling and small triangle discard stage 316 performs various culling operations involving removal of elements that will not impact the final rendered scene...In some embodiments, the culling and small triangle discard stage 316 includes a back-face culling to discard primitives that are invisible to the view camera because the back face of such elements faces away from the camera... In some embodiments, the culling and small triangle discard stage 316 includes occlusion culling to discard primitives that are blocked or occluded by other elements and are therefore not visible in the rendered scene.”; Favela, [0050])
The culling stage 316 performs, for example back-face culling to discard primitives that are invisible to the camera and occlusion culling to discard primitives that are occluded and not visible in the rendered scene (culling the set of primitives by the one or more shader engines). By culling the primitives that are not visible, the visible primitives are identified (culling the set of primitives comprises identifying a subset of the primitives that are potentially visible in the scene).
generating, by the shader engine , attribute data values for the identified subset of primitives; (“The deferred parameter calculations stage 318 performs attribute calculations after primitives are culled in the culling and small triangle discard stage 316. The advantage of performing these attribute calculations after culling is that non-visible primitives have been discarded and so attributes are not determined for primitives that do not contribute to the final scene... For example, in various embodiments, the non-position attributes include but are not limited to attributes such as color, texture, surface normal and the like.”; Favela, [0051])
The deferred parameter calculations stage 318 performs attribute calculations (generating, by the one or more shader engines, attribute data values) after primitives are culled such that the attributes are only determined for visible primitives (for the identified subset of primitives).
Favela is silent regarding rasterizing the identified subset of primitives, by the one or more shader engines, for rendering based on the generated attribute data values, however, Zhu teaches
and rasterizing the identified subset of primitives, by the shader engine , for rendering based on the generated attribute data values. (“Raster/shading-after-z refers to a preliminary visibility computation that has been performed to throw away invisible geometries/fragments. For example, double-z as described earlier generates only visible opaque primitives/fragments and potentially visible transparent primitives/fragments.”; Zhu, col. 15, lines 32-37)
For raster/shading-after-z, a preliminary visibility determination has been performed to cull invisible geometries/fragments (primitives) such that only visible primitives/fragments are generated.
(“Because a raster/shading-after-z mechanism such as double-z has already been applied to eliminate invisible geometries/fragments in the scan/z engine, only visible primitives and their corresponding visible fragments are dealt with by the raster/shading engine. The output from the raster/shading engine is sent to the blending engine... where the final pixel colors are resolved.”; Zhu, col. 15, lines 43-50)
Since primitives that are not visible have been removed, only visible primitives (the identified subset of primitives) and their corresponding visible fragments are dealt with by the raster/shading engine (rasterizing the identified subset of primitives, by the one or more shader engines). Then, the rasterized and shaded primitives and corresponding fragments are sent to the blending engine, which is considered to be included in output merger for rendering (for rendering based on the generated attribute data values). Favela and Zhu are silent regarding one shader engine performing culling, generating attribute data and rasterizing, however, Nordlund teaches this limitation.
(“... small primitive processing unit 56 may receive processed primitive information from rasterization mode selector 36, and perform primitive processing on the graphics primitive to generate polygon information for the primitive... Small primitive processing unit 56 may include fixed function hardware to perform clipping or scissoring of the polygon against the pixel boundaries, to perform back face culling... Small primitive processing unit 56 may also include functionality to perform primitive setup operations to calculate differentials, edge functions, plane equations and/or other data that is used by fragment shader 52 for rasterization of the primitive. Small primitive processing unit 56 may also include functionality to determine color values and other attributes values in preparation for rasterization of the primitive by the fragment shader 52. Performing one or more rasterization operations in the dedicated hardware or small primitive processing unit 56 may free up resources in fragment shader 52 for performing operations that would otherwise be a performance bottleneck for fragment shader 52.”; Nordlund, [0083], [0084], Fig. 5)
Fig. 5 illustrates a small primitive processing unit that is considered to be combined with the fragment shader to perform culling, generate attribute values and rasterization. Zhu and Nordlund are combined with Favela such that the visible primitives of the raster/shading engine include the attribute data of Favela and such that the combined small primitive processing unit and fragment shader perform the operations of the shaders of Favela. Therefore, it would have been obvious to one of ordinary skill in the art at the time of the effective filing date, to modify the method of Favela by adding the feature of r rasterizing the identified subset of primitives, by the one or more shader engines, for rendering based on the generated attribute data values, in order to provide efficient use of processing capabilities and memory bandwidth through the intelligent management of primitive rendering and memory usage while retaining coherence, as taught by Zhu (col. 5, lines 12-16) and in order to free up resources in the fragment shader to avoid performance bottlenecks, as taught by Nordlund ([0084]).
Claim 9 is an acceleration unit analogous to the method of claim 1, is similar in scope and is rejected under the same rationale. Claim 1 has additional limitations. Re: claim 9, Favela teaches
9. (Currently Amended) An acceleration unit comprising: one or more caches; and a shader engine coupled to the one or more caches, the a shader engine configured to: (“Fig. 1 is a block diagram of a processing system 100... The processing system 100 includes a central processing unit (CPU) 102 and an accelerated processing device (APD) 104.”; Favela, [0010], Fig. 1)
Fig. 1 illustrates a processing system 100 that includes an accelerated processing device (acceleration unit)
(“To reduce latency associated with off-chip memory access, various APD architectures include a memory cache hierarchy (not shown) including, for example, L1 cache and a local data share (LDS).”; Favela, [0021])
The accelerated processing device includes a memory cache hierarchy including, for example and L1 cache (one or more caches).
(“Some embodiments of the APD 104 are used to implement a GPU and, in that case, the processing cores 122 are referred to as shader cores or streaming multi-processors (SMX).”; Favela, [0018])
Fig. 1 illustrates that the accelerated processing device implements a GPU and processing cores that are shader cores (shader engines coupled to the one or more caches).
Claim 16 is a medium analogous to the method of claim 1, is similar in scope and is rejected under the same rationale. Claim 16 has additional limitations. Re: claim 16, Favela teaches
16. (Original) A non-transitory computer readable medium embodying a set of executable instructions, the set of executable instructions to manipulate at least one processor to: (“In some embodiments, certain aspects of the techniques described above may implemented by one or more processors of a processing system executing software. The software includes one or more sets of executable instructions stored or otherwise tangibly embodied on a non-transitory computer readable storage medium. The software can include the instructions and certain data that, when executed by the one or more processors, manipulate the one or more processors to perform one or more aspects of the techniques described above.”; Favela, [0061])
One or more sets of executable instructions are stored on a non-transitory computer readable storage medium, that when executed by one or more processors manipulate the one or more processors to perform aspects of the techniques.
Re: claims 2 and 17 (which are rejected under the same rationale), Favela, Zhu and Nordlund teach
2. (Currently Amended) The method of claim 1, further comprising generating, by the shader engine , intermediate data for the identified subset of primitives, and wherein the method is performed without providing, external to a plurality of shader engines that includes the shader engine, the intermediate data or the attribute data values. (“The deferred parameter calculations stage 318 performs attribute calculations after primitives are culled in the culling of small triangle discard stage 316. The advantage of performing these attribute calculations after culling is that non-visible primitives have been discarded so attributes are not determined for primitives that do not contribute to the final scene.”; Favela, [0051], Fig. 3)
Fig. 3 illustrates that the deferred attribute shading stages 302 include a deferred parameter calculations stage that determines (generating, by the one or more shader engines) attributes (intermediate data) for the primitives that are visible (identified subset of primitives). Fig. 3 also illustrates that the intermediate data or attribute data is generated within the deferred attribute shading stages 302 (the method is performed without providing, external to the one or more shader engines, the intermediate data or the attribute data values).
Re: claim 10, Favela, Zhu and Nordlund teach
10. (Currently Amended) The acceleration unit of claim 9, wherein the shader engine is further configured to generate intermediate data for the identified subset of primitives, and to generate the attribute data values and rasterize the identified subset of primitives without providing, external to a plurality of shader engines that includes the shader engine, the intermediate data or the attribute data values. (“The deferred parameter calculations stage 318 performs attribute calculations after primitives are culled in the culling of small triangle discard stage 316. The advantage of performing these attribute calculations after culling is that non-visible primitives have been discarded so attributes are not determined for primitives that do not contribute to the final scene... For example... the non-position attributes include but are not limited to attributes such as color, texture, surface normal, and the like... the non-position attributes further include auxiliary position attributes that are required by the rasterization pipeline (e.g., render target array index, viewport array index, and the like), but are not XYZW position values”; Favela, [0051], Fig. 3)
Fig. 3 illustrates that the deferred attribute shading stages 302 include a deferred parameter calculations stage that determines (the shader engines) shader engine non-position attributes are used by the rasterization pipeline (generate attribute data values and rasterize the identified subset of primitives without providing, external to a plurality of shader engines that includes the shader engine, the intermediate data or the attribute data values).
Re: claims 5 and 20 (which are rejected under the same rationale), Favela, Zhu and Nordlund teach
5. (Original) The method of claim 1, wherein rasterizing the identified subset of primitives comprises generating a rasterized subset of primitives, and wherein the method further comprises rendering the scene by generating pixel data based on the rasterized subset of primitives. (“Because a raster/shading-after-z mechanism such as double -z has already been applied to eliminate invisible geometries/fragments in the scan/z engine, only visible primitives and their corresponding visible fragments are dealt with by the raster/shading engine.”; Zhu, col. 15, lines 43-47)
Only visible primitives (subset of primitives) and corresponding visible fragments or processed by the raster/shading engine (generating a rasterized subset of primitives).
(“Screen geometries 701 and visible fragments 70 are input 703 into the raster/shading engine. Only primitive parameters for visible primitives are setup 704 705. The visible fragment parameters are then computed 705 using previous setup information. Shading 706 is performed using the texture data 708. The result from the shading 706 is then sent to the blending engine 708”; Zhu, col. 16, lines 2-6, Fig. 7)
In the raster/shading engine, after the raster processing, shading is performed. Then, the rasterized and shaded primitives and corresponding fragments are sent to the blending engine, which is considered to be included in output merger for rendering (rendering the scene by generating pixel data based on the rasterized subset of primitives). Therefore, it would have been obvious to one of ordinary skill in the art at the time of the effective filing date, to modify the method of Favela by adding the feature of rasterizing the identified subset of primitives comprises generating a rasterized subset of primitives, and wherein the method further comprises rendering the scene by generating pixel data based on the rasterized subset of primitives, in order to provide efficient use of processing capabilities and memory bandwidth through the intelligent management of primitive rendering and memory usage while retaining coherence, as taught by Zhu (col. 5, lines 12-16).
Re: claim 13, Favela, Zhu and Nordlund teach
13. (Currently Amended) The acceleration unit of claim 9, wherein to rasterize the identified subset of primitives comprises generating a rasterized subset of primitives, and wherein the shader engine is configured to render the scene by generating pixel data based on the rasterized subset of primitives. (“Because a raster/shading-after-z mechanism such as double -z has already been applied to eliminate invisible geometries/fragments in the scan/z engine, only visible primitives and their corresponding visible fragments are dealt with by the raster/shading engine.”; Zhu, col. 15, lines 43-47)
Only visible primitives (subset of primitives) and corresponding visible fragments or processed by the raster/shading engine (generating a rasterized subset of primitives).
(“Screen geometries 701 and visible fragments 70 are input 703 into the raster/shading engine. Only primitive parameters for visible primitives are setup 704 705. The visible fragment parameters are then computed 705 using previous setup information. Shading 706 is performed using the texture data 708. The result from the shading 706 is then sent to the blending engine 708”; Zhu, col. 16, lines 2-6, Fig. 7)
In the raster/shading engine (shader engine), after the raster processing, shading is performed. Then, the rasterized and shaded primitives and corresponding fragments are sent to the blending engine, which is considered to be included in output merger for rendering (render the scene by generating pixel data based on the rasterized subset of primitives). Therefore, it would have been obvious to one of ordinary skill in the art at the time of the effective filing date, to modify the method of Favela by adding the feature of rasterize the identified subset of primitives comprises generating a rasterized subset of primitives, and wherein the shader engine is configured to render the scene by generating pixel data based on the rasterized subset of primitives, in order to provide efficient use of processing capabilities and memory bandwidth through the intelligent management of primitive rendering and memory usage while retaining coherence, as taught by Zhu (col. 5, lines 12-16).
Re: claims 7 and 15 (which are rejected under the same rationale), Favela, Zhu and Nordlund teach
7. (Original) The method of claim 1, wherein receiving the set of primitives comprises receiving one or more of a group that includes geometry data associated with the set of primitives, geometry state data associated with the scene, or pixel state data. (“Figs. 1-4 disclose systems and techniques to improve the efficiency of graphics processing pipelines... a method of deferred vertex attributes shading includes computing, at a graphics processing pipeline of a graphics processing unit (GPU), a plurality of vertex attributes for vertices of each primitive... of a set of primitives. Geometry data includes graphics data items which describe geometry to be rendered. For example, the graphics data items represent geometric shapes, which describe surfaces of structures in the scene and which are referred to as “primitives”... Scenes typically contain many objects, with objects are composed of one or more such primitives (e.g., objects can be composed of many thousands, or even millions of such primitives.”; Favela, [0008])
The graphics processing pipeline receives vertices of each primitive of the set of primitives. The primitives include graphics data which describe the geometry (geometry data associated with the set of primitives) to be rendered such as, for example, surfaces of structures in a scene (geometry state data associated with the scene) (receiving one or more of a group that includes geometry data associated with the set of primitives, geometry state data associated with the scene, or pixel state data).
Re: claim 8, Favela, Zhu and Nordlund teach
8. (Currently Amended) The method of claim 1, wherein the method is performed by a processor core comprising the shader engine . (“Some embodiments of the APD 104 are used to implement a GPU and, in that case, the processing cores 122 are referred to as shader cores or streaming multi-processors (SMX).”; Favela, [0018])
Fig. 1 illustrates that the accelerated processing device (APD) 104 includes processing cores 122, which are shader cores (shader engine).
Claim(s) 3, 4, 11, 12, 18 and 19 are is/are rejected under 35 U.S.C. 103 as being unpatentable over Favela in view of Zhu and Nordlund as applied to claim 2 above, and further in view of Park et al. U.S. Pub. No. 2014/0333620.
Re: claims 3 and 18 (which are rejected under the same rationale), Favela, Zhu and Nordlund teach
3. The method of claim 2, wherein: generating the intermediate data for the identified subset of primitives comprises generating intermediate geometry data for the identified subset; (“The deferred parameter calculations stage 318 performs attribute calculations after primitives are culled in the culling of small triangle discard stage 316. The advantage of performing these attribute calculations after culling is that non-visible primitives have been discarded so attributes are not determined for primitives that do not contribute to the final scene.”; Favela, [0051], Fig. 3)
Fig. 3 illustrates that the deferred attribute shading stages 302 include a deferred parameter calculations stage that determines (generates) attributes (intermediate geometry data) for the primitives that are visible (identified subset).
Favela, Zhu and Nordlund are silent regarding rasterizing the identified subset of primitives comprises rasterizing the identified subset based on the intermediate geometry data, however Park teaches
and rasterizing the identified subset of primitives comprises rasterizing the identified subset based on the intermediate geometry data. (“The primitive assembly unit 114 generates and assembles a primitive composed of one or more vertexes. For example, the primitive assembly unit 114 can assemble a triangular primitive composed of three vertexes... when the primitive assembly unit 114 assembles primitives, texture patches corresponding to the assembled primitives are defined, information concerning the texture patches may also be generated.”; Park, [0050], [0053], Fig. 2)
Fig. 2 illustrates that the GPU 100 includes a graphics pipeline that includes a primitive assembly unit 114 that assembles primitives from vertices. When the primitives are assembled, texture patches corresponding to the assembled primitives (intermediate geometry data) are defined.
(“The tiling unit 116 performs tile binning on the received primitive and can approximately determine which tile is touched by the primitive. The touching of the tile by the primitive may mean that at least a portion of the primitive belongs to an inside of the corresponding tile. In addition, the tiling unit 116 can allocate the primitive touching the tile to a list of primitives for each tile, as shown in Fig. 7, for example.”; Park, [0066], Fig. 7)
Fig. 2 illustrates a tiling unit that bins the assembled primitives and determines which primitive belongs to each tile. This information is added to a list of primitives for each tile.
(“Referring to Fig. 8, the rasterizer 122 includes a primitive list reader 122a, an interpolation unit 122b and an early depth tester 122c... The primitive list reader 122a reads the primitive list for each tile from the external memory 200. The primitive list reader 122a may receive the primitives belonging to each tile in a rendering order... The interpolation unit 122b generates a set of fragments using the primitives received from the primitive list reader 122a... The interpolation unit 122b interpolates values of vertexes constituting the primitives to determine the positions, normal vectors, color values and so on of the fragments.”; Park, [0076], [0077], [0078], Figs 2 and 8)
Figs. 2 and 8 illustrate a rasterizer that includes a primitive list reader and an interpolation unit. The primitive list reader receives the primitives (intermediate geometry data) for each tile in a rendering order. The interpolation unit generates fragments using the primitives from the primitive list reader and interpolates values for primitive vertices to determine, for example, color values, and normal values of the fragments (rasterizing the identified subset based on the intermediate geometry data). Park is combined with Favela and Zhu such that the primitives received by the rasterizer of Park are the visible primitives of Favela and Zhu. Therefore, it would have been obvious to one of ordinary skill in the art at the time of the effective filing date, to modify the method of Favela by adding the feature of rasterizing the identified subset of primitives comprises rasterizing the identified subset based on the intermediate geometry data, in order to provide a rendering method using a graphics processing unit having improved processing performance, as taught by Park ([0007]).
Re: claim 11, Favela, Zhu and Nordlund teach
11. (Currently Amended) The acceleration unit of claim 10, wherein: the intermediate data for the identified subset of primitives includes intermediate geometry data for the identified subset; (“The deferred parameter calculations stage 318 performs attribute calculations after primitives are culled in the culling of small triangle discard stage 316. The advantage of performing these attribute calculations after culling is that non-visible primitives have been discarded so attributes are not determined for primitives that do not contribute to the final scene.”; Favela, [0051], Fig. 3)
Fig. 3 illustrates that the deferred attribute shading stages 302 include a deferred parameter calculations stage that determines attributes (intermediate geometry data) for the primitives that are visible (identified subset).
Favela, Zhu and Nordlund are silent regarding the shader engine is configured to rasterize the identified subset of primitives based on the intermediate geometry data, however Park teaches
and the shader engine is configured to rasterize the identified subset of primitives based on the intermediate geometry data. (“The primitive assembly unit 114 generates and assembles a primitive composed of one or more vertexes. For example, the primitive assembly unit 114 can assemble a triangular primitive composed of three vertexes... when the primitive assembly unit 114 assembles primitives, texture patches corresponding to the assembled primitives are defined, information concerning the texture patches may also be generated.”; Park, [0050], [0053], Fig. 2)
Fig. 2 illustrates that the GPU 100 includes a graphics pipeline that includes a primitive assembly unit 114 that assembles primitives from vertices. When the primitives are assembled, texture patches corresponding to the assembled primitives (intermediate geometry data) are defined.
(“The tiling unit 116 performs tile binning on the received primitive and can approximately determine which tile is touched by the primitive. The touching of the tile by the primitive may mean that at least a portion of the primitive belongs to an inside of the corresponding tile. In addition, the tiling unit 116 can allocate the primitive touching the tile to a list of primitives for each tile, as shown in Fig. 7, for example.”; Park, [0066], Fig. 7)
Fig. 2 illustrates a tiling unit that bins the assembled primitives and determines which primitive belongs to each tile. This information is added to a list of primitives for each tile.
(“Referring to Fig. 8, the rasterizer 122 includes a primitive list reader 122a, an interpolation unit 122b and an early depth tester 122c... The primitive list reader 122a reads the primitive list for each tile from the external memory 200. The primitive list reader 122a may receive the primitives belonging to each tile in a rendering order... The interpolation unit 122b generates a set of fragments using the primitives received from the primitive list reader 122a... The interpolation unit 122b interpolates values of vertexes constituting the primitives to determine the positions, normal vectors, color values and so on of the fragments.”; Park, [0076], [0077], [0078], Figs 2 and 8)
Figs. 2 and 8 illustrate a rasterizer that includes a primitive list reader and an interpolation unit. The primitive list reader receives the primitives (intermediate geometry data) for each tile in a rendering order. The interpolation unit generates fragments using the primitives from the primitive list reader and interpolates values for primitive vertices to determine, for example, color values, and normal values of the fragments (rasterize the identified subset of primitives based on the intermediate geometry data). Park is combined with Favela, Zhu such that the primitives received by the rasterizer of Park are the visible primitives of Favela and Zhu. Therefore, it would have been obvious to one of ordinary skill in the art at the time of the effective filing date, to modify the method of Favela by adding the feature of the shader engine is configured to rasterize the identified subset of primitives based on the intermediate geometry data, in order to provide a rendering method using a graphics processing unit having improved processing performance, as taught by Park ([0007]).
Re: claims 4 and 19 (which are rejected under the same rationale), Favela and Zhu teach
4. The method of claim 2, wherein: generating the intermediate data for the identified subset of primitives comprises generating assembled primitive data for the identified subset of primitives; (“The rasterization processing stage 240 depicted in the figure includes a primitive assembly stage 242, which sets up the primitives defined by each set of vertices in the scene... During the primitive assembly stage 242, certain primitives are optionally culled. For example, those primitives whose vertex indices and homogeneous coordinate space positions indicate a certain winding order are considered to be back-facing and therefore culled from the scene.”; Favela, [0038])
Fig. 2 illustrates a primitive assembler 242 that sets up the primitives (generating assembled primitive data) defined by vertices and culls primitives that are not visible (generating assembled primitive data for the identified subset of primitives)
Favela and Zhu are silent regarding generating the attribute data values comprises generating the attribute data values based on the assembled primitive data, however, Park teaches
and generating the attribute data values comprises generating the attribute data values based on the assembled primitive data. (“The primitive assembly unit 114 generates and assembles a primitive composed of one or more vertexes. For example, the primitive assembly unit 114 can assemble a triangular primitive composed of three vertexes... when the primitive assembly unit 114 assembles primitives, texture patches corresponding to the assembled primitives are defined, information concerning the texture patches may also be generated.”; Park, [0050], [0053], Fig. 2)
Fig. 2 illustrates a primitive assembly unit 114 that assembles primitives from vertices. When the primitives are assembled, texture patches (generating the attribute data values) corresponding to the assembled primitives are defined (generating the attribute data values based on the assembled primitive data). Park is combined with Favela and Zhu such that the assembled primitives of Zhu are the assembled primitives of Favela. Therefore, it would have been obvious to one of ordinary skill in the art at the time of the effective filing date, to modify the method of Favela by adding the feature of generating the attribute data values comprises generating the attribute data values based on the assembled primitive data, in order to provide a rendering method using a graphics processing unit having improved processing performance, as taught by Park ([0007]).
Re: claim 12, Favela, Zhu and Nordlund teach
12. (Currently Amended) The acceleration unit of claim 10, wherein: the intermediate data for the identified subset of primitives comprises assembled primitive data for the identified subset of primitives; (“The rasterization processing stage 240 depicted in the figure includes a primitive assembly stage 242, which sets up the primitives defined by each set of vertices in the scene... During the primitive assembly stage 242, certain primitives are optionally culled. For example, those primitives whose vertex indices and homogeneous coordinate space positions indicate a certain winding order are considered to be back-facing and therefore culled from the scene.”; Favela, [0038])
Fig. 2 illustrates a primitive assembler 242 that sets up the primitives (generating assembled primitive data) defined by vertices and culls primitives that are not visible (generating assembled primitive data for the identified subset of primitives)
Favela, Zhu and Nordlund are silent regarding generating the attribute data values comprises generating the attribute data values based on the assembled primitive data, however, Park teaches
and the shader engine is configured to generate the attribute data values based on the assembled primitive data. (“The primitive assembly unit 114 generates and assembles a primitive composed of one or more vertexes. For example, the primitive assembly unit 114 can assemble a triangular primitive composed of three vertexes... when the primitive assembly unit 114 assembles primitives, texture patches corresponding to the assembled primitives are defined, information concerning the texture patches may also be generated.”; Park, [0050], [0053], Fig. 2)
Fig. 2 illustrates a primitive assembly unit 114 that assembles primitives from vertices. When the primitives are assembled, texture patches (generate the attribute data values) corresponding to the assembled primitives are defined (generate the attribute data values based on the assembled primitive data). Park is combined with Favela, Zhu and Nordlund such that the assembled primitives of Zhu are the assembled primitives of Favela. Therefore, it would have been obvious to one of ordinary skill in the art at the time of the effective filing date, to modify the method of Favela by adding the feature of the shader engine is configured to generate the attribute data values comprises generating the attribute data values based on the assembled primitive data, in order to provide a rendering method using a graphics processing unit having improved processing performance, as taught by Park ([0007]).
Claim(s) 6 and 14 is/are rejected under 35 U.S.C. 103 as being unpatentable over Favela in view of Zhu and Nordlund as applied to claims 1 and 9 above, and further in view of Chung et al. U.S. Pub. No. 2016/0148424.
Re: claim 6, Favela, Zhu and Nordlund are silent regarding splitting the scene into a plurality of tiles, wherein the set of primitives corresponds to all primitives associated with one tile of the plurality of tiles and wherein the method further comprises rendering the frame for display, however, Chung teaches
6. (Currently Amended) The method of claim 1, further comprising splitting a frame representing the scene into a plurality of tiles, wherein the set of primitives corresponds to all primitives associated with one tile of the plurality of tiles (“In one example, the GPU 10 may perform a tile-based graphics pipeline or a tile-based rendering (TBR). In this context, the term “tile-based” means that each frame of a moving image is divided or partitioned into a plurality of tiles, and the rendering is performed per tile.”; Chung, [0100], [0106])
The GPU performs a tile-based graphics pipeline that divides or partitions each frame into a plurality of tiles.
(“In one example, the object 220 may be a 3D object, such as a car object 220 which is presented in one frame 200 of a moving image. The GPU 10 partitions the frame 200 including the 3D car object 220 into NxM tiles 210, wherein N and M are each natural numbers.”; Chung, [0106], Fig. 2)
Fig. 2 illustrates that the GPU partitions frame 200 into a plurality of tiles (splitting the scene into a plurality of tiles).
(“The binner 135 performs binning or tiling using output primitives from the domain shader 125 or the geometry shader 130. In other words, the binner 135 generates (bins) a tile list indicating information about each of tiles to which the output primitives belong, by performing a depth test (or a tile Z test).”; Chung, [0121], Fig. 6)
Fig. 6 illustrates that graphics pipeline includes a binner that generates a tile list indicating which primitives belong to each (one tile) tile (wherein the set of primitives corresponds to all primitives associated with one tile of the plurality of tiles). Chung is combined with Favela and Zhu such that the primitives that belong to each tile of Chung are the visible primitives of Favela and Zhu.
and wherein the method further comprises rendering the frame for display. (“In this example, the binning pipeline 101 partitions the frame including the car object 220 into the tiles 210 and determines which tiles 210 include the car object 220. The GPU 10 renders the car object 220 per tile to convert the car object 220 to pixel expressions.”; Chung, [0106])
Fig. 2 illustrates the rendered frame. The GPU renders the frame (rendering the frame for display), that includes the car, on a per tile basis. Therefore, it would have been obvious to one of ordinary skill in the art at the time of the effective filing date, to modify the method of Favela by adding the feature of splitting the scene into a plurality of tiles, wherein the set of primitives corresponds to all primitives associated with one tile of the plurality of tiles and wherein the method further comprises rendering the frame for display, in order to increase graphics processing performance or efficiency by reducing the amount of rendering, as taught by Chung ([0129]-[0130]).
Re: claim 14, Favela, Zhu and Nordlund teach
14 (Currently Amended) The acceleration unit of claim 9, wherein the shader engine is further configured to divide a frame that represents the scene into a plurality of tiles, and wherein the set of primitives corresponds to all primitives associated with one tile of the plurality of tiles. (“In one example, the GPU 10 may perform a tile-based graphics pipeline or a tile-based rendering (TBR). In this context, the term “tile-based” means that each frame of a moving image is divided or partitioned into a plurality of tiles, and the rendering is performed per tile.”; Chung, [0100], [0106])
The GPU performs a tile-based graphics pipeline that divides or partitions each frame into a plurality of tiles (divide a frame that represents the scene into a plurality of tiles).
(“In one example, the object 220 may be a 3D object, such as a car object 220 which is presented in one frame 200 of a moving image. The GPU 10 partitions the frame 200 including the 3D car object 220 into NxM tiles 210, wherein N and M are each natural numbers.”; Chung, [0106], Fig. 2)
Fig. 2 illustrates that the GPU partitions frame 200 into a plurality of tiles divide a frame that represents the scene into a plurality of tiles).
(“The binner 135 performs binning or tiling using output primitives from the domain shader 125 or the geometry shader 130. In other words, the binner 135 generates (bins) a tile list indicating information about each of tiles to which the output primitives belong, by performing a depth test (or a tile Z test).”; Chung, [0121], Fig. 6)
Fig. 6 illustrates that graphics pipeline includes a binner that generates a tile list indicating which primitives belong to each (one tile) tile (wherein the set of primitives corresponds to all primitives associated with one tile of the plurality of tiles). Chung is combined with Favela and Zhu such that the primitives that belong to each tile of Chung are the visible primitives of Favela and Zhu. Therefore, it would have been obvious to one of ordinary skill in the art at the time of the effective filing date, to modify the method of Favela by adding the feature of the shader engine is further configured to divide a frame that represents the scene into a plurality of tiles, wherein the set of primitives corresponds to all primitives associated with one tile of the plurality of tiles, in order to increase graphics processing performance or efficiency by reducing the amount of rendering, as taught by Chung ([0129]-[0130]).
Response to Arguments
Applicant’s arguments, see Amendment/Request for Reconsideration-After Non-Final Rejection, filed 1/05/2026, with respect to the 35 U.S.C § 112(a) Rejection of claims 6 and 14 have been fully considered and are persuasive. The 35 U.S.C § 112(a) Rejection of the previous Office Action has been withdrawn.
Applicant's arguments filed 1/05/2026 have been fully considered but they are not persuasive. Applicant argues:
“The Office acknowledges that Favela fails to disclose rasterizing an identified subset of primitives by a shader engine for rendering based on generated attribute data values. (Office Action at 7). To cure this deficiency, the Office cites Zhu as generally describing a group of shader engines that rasterize a subset of primitives. (Id. at 7-8, citing Zhu at column/lines 15/32- 50). However, these are not the features of independent claim 1 as amended, which explicitly indicates that the same shader engine is performing the recited operations of culling a received set of primitives to identify a potentially visible subset, generation of attribute data values for that identified subset, and rasterizing primitives of the identified subset. ”
Examiner disagrees. As discussed in the 35 U.S.C § 112(a) Rejection, the same shader performing all of the different operations of, for example, claim 1, is considered to be NEW MATTER. Favela, Zhu and Nordlund teach the recitations of claim 1. For example, Nordlund illustrates in Fig. 5, a small primitive processing unit that is considered to be combined with the fragment shader to perform culling, generate attribute values and rasterization. (Nordlund, [0083], [0084], Fig. 5). Claim 1 has been rejected. Please see the rejection for claim 1.
Applicant's arguments filed 1/05/2026 have been fully considered but they are not persuasive. Applicant argues:
“In contrast, Zhu teaches a decoupled architecture that splits these operations across physically distinct hardware units to allow for load balancing. (Zhu at column/lines 12/60-65 and 13/10-25.) Zhu describes a dedicated "scan/z engine" (403) that performs the visibility determination (culling) and a separate, distinct "raster" engine (405) that performs the rasterization of visible fragments. (Id. at Fig. 4 and column/lines 4/50-55.) Zhu emphasizes that this separation is critical to its design, stating that "the double-z scheme ... decouples the scan conversion/depth-buffer processing [scan/z engine] from the more general rasterization and shading processing [raster engine]." (Id. at column/lines 3/67-4/10.). Thus, as with Favela, Zhu at least fails to disclose rasterizing the identified subset of primitives by any shader engine that also performs the culling and attribute value generation operations, as generally recited by claim 1. Even if Favela and Zhu were combined as proposed by the Office, the resulting system would distribute the claimed steps across disparate hardware units-using Favela's shader cores (or Zhu's scan/z engine) for culling and Zhu's distinct raster engine for rasterization-rather than consolidating execution onto a single shader engine that performs those disparate operations as claimed. For at least these reasons, the relied-upon references fail, whether considered individually or in combination, to disclose or render obvious the features of independent claim 1. Moreover, although the language and scope of independent claims 9 and 16 are not identical to those of claim 1, the allowability of those additional independent claims will be readily apparent in view of the discussion above, mutatis mutandis.”
Examiner disagrees. As discussed in the 35 U.S.C § 112(a) Rejection, the same shader performing all of the different operations of, for example, claim 1, is considered to be NEW MATTER. Favela, Zhu and Nordlund teach the recitations of claim 1. For example, Nordlund illustrates in Fig. 5, a small primitive processing unit that is considered to be combined with the fragment shader to perform culling, generate attribute values and rasterization. (Nordlund, [0083], [0084], Fig. 5). Claims 1, 9 and 16 have been rejected. Please see the corresponding rejections.
Applicant's arguments filed 1/05/2026 have been fully considered but they are not persuasive. Applicant argues:
“Each of claims 2, 5, 7, 8, 10, 13, 15, 17, and 20 respectively depends from one of independent claims 1, 9, and 16. As discussed above, the cited Favela and Zhu references, individually and in combination, fail to disclose or render obvious the features of those independent claims. The cited references therefore fail to disclose the features of dependent claims 2, 5, 7, 8, 10, 13, 15, 17, and 20, at least by virtue of their respective dependence from claims 1, 9, and 16. In addition, these dependent claims recite additional novel and non-obvious features. In view of the foregoing, withdrawal of the above-referenced obviousness rejection and reconsideration of the claims is respectfully requested. ”
Examiner disagrees. As discussed above, in the arguments for the independent claims, the independent claims are rejected by Favela, Zhu and Nordlund. Claims 1, 9, 16 as well as claims 2, 5, 7, 8, 10, 13, 15, 17, and 20 have been rejected. Please see the corresponding rejections.
Applicant's arguments filed 1/05/2026 have been fully considered but they are not persuasive. Applicant argues:
“Each of claims 3, 4, 11, 12, 18, and 19 respectively depends from one of independent claims 1, 9, and 16. As discussed above, the cited Favela and Zhu references, individually and in combination, fail to disclose or render obvious the features of those independent claims. Further, Park does not remedy the discussed deficiencies of Favela and Zhu, and the Office does not appear to allege that it does so. Accordingly, the cited references, individually and in combination, fail to disclose or render obvious the features of independent claims 1, 9, and 16, and further fail to disclose the features of dependent claims 3, 4, 11, 12, 18, and 19 at least by virtue of their respective dependence from those independent claims. In addition, these dependent claims recite additional novel and non-obvious features. In view of the foregoing, withdrawal of the above-referenced obviousness rejection and reconsideration of the claims is respectfully requested.”
Examiner disagrees. As discussed above, in the arguments for the independent claims, the independent claims are rejected by Favela, Zhu and Nordlund. Claims 1, 9, 16 as well as claims 3, 4, 11, 12, 18, and 19 have been rejected. Please see the corresponding rejections.
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 DONNA J RICKS whose telephone number is (571)270-7532. The examiner can normally be reached on M-F 7:30am-5pm EST (alternate Fridays off).
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, Devona Faulk can be reached on 571-272-7776. The fax phone number for the organization where this application or proceeding is assigned is 571-273-8300.
Information regarding the status of an application may be obtained from the Patent Application Information Retrieval (PAIR) system. Status information for published applications may be obtained from either Private PAIR or Public PAIR. Status information for unpublished applications is available through Private PAIR only. For more information about the PAIR system, see https://ppair-my.uspto.gov/pair/PrivatePair. Should you have questions on access to the Private PAIR system, contact the Electronic Business Center (EBC) at 866-217-9197 (toll-free). If you would like assistance from a USPTO Customer Service Representative or access to the automated information system, call 800-786-9199 (IN USA OR CANADA) or 571-272-1000.
/Donna J. Ricks/Examiner, Art Unit 2612
/DEVONA E FAULK/Supervisory Patent Examiner, Art Unit 2618