US6975321B1 - System and method for generating multiple outputs in a single shader processing pass in a hardware graphics pipeline - Google Patents
System and method for generating multiple outputs in a single shader processing pass in a hardware graphics pipeline Download PDFInfo
- Publication number
- US6975321B1 US6975321B1 US10/430,629 US43062903A US6975321B1 US 6975321 B1 US6975321 B1 US 6975321B1 US 43062903 A US43062903 A US 43062903A US 6975321 B1 US6975321 B1 US 6975321B1
- Authority
- US
- United States
- Prior art keywords
- output packets
- shader
- recited
- output
- memory
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Expired - Lifetime, expires
Links
- 238000012545 processing Methods 0.000 title claims abstract description 58
- 238000000034 method Methods 0.000 title claims abstract description 44
- 230000015654 memory Effects 0.000 claims description 45
- 239000000872 buffer Substances 0.000 claims description 34
- 239000004065 semiconductor Substances 0.000 claims description 12
- 238000012360 testing method Methods 0.000 claims description 6
- 239000013598 vector Substances 0.000 claims description 5
- 238000009877 rendering Methods 0.000 description 6
- 238000013507 mapping Methods 0.000 description 5
- 230000006870 function Effects 0.000 description 3
- 230000008901 benefit Effects 0.000 description 2
- 239000003086 colorant Substances 0.000 description 2
- 241000854350 Enicospilus group Species 0.000 description 1
- 238000013459 approach Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 239000012634 fragment Substances 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06T—IMAGE DATA PROCESSING OR GENERATION, IN GENERAL
- G06T15/00—3D [Three Dimensional] image rendering
- G06T15/005—General purpose rendering architectures
Abstract
A system and method are provided for generating multiple output packets in a single processing pass of a shader in a hardware graphics pipeline. Initially, graphics data is received, after which it is processed utilizing the shader of the hardware graphics pipeline to generate a plurality of output packets. The plurality of output packets is outputted from the shader of the hardware graphics pipeline in the single processing pass.
Description
The present invention relates to computer graphics processing, and more particularly to shader processing in a hardware graphics pipeline.
Recent advances in computer performance have enabled hardware graphics systems to provide more realistic graphical images using personal computers and home video game computers. In such graphic systems, some procedure must be implemented to “render” or draw graphic primitives to the screen of the system. A “graphic primitive” is a basic component of a graphic picture, such as a polygon, a triangle, a line or a point. All graphic pictures are formed with combinations of these graphic primitives. Many procedures may be utilized to perform graphic primitive rendering.
Early graphic systems displayed images representing objects using just colored polygons. That is, textures, bumps, scratches, or other surface features were very expensive to model because they had to be drawn with individual polygons. In order to improve the quality of the image, texture mapping was developed to model the complexity of real world surface images. In general, texture mapping is the mapping of an image or a function onto a surface. Texture mapping is a relatively efficient technique for creating the appearance of a complex image without the tedium and the high computational cost of rendering the actual three dimensional detail that might be found on a surface of an object.
In recent prior art, texture mapping has been conducted with pixel shading techniques. Prior Art FIG. 1 illustrates a graphics system 100 equipped with pixel shading capabilities. As shown, the graphics system 100 is equipped with a 3-D graphics pipeline 108 capable of receiving graphics data 102, 104, 106. Such graphics data may include geometry which is transform, lighted, and rendered during the course of graphics processing utilizing the 3-D graphics pipeline 108. Various aspects of the foregoing processing may be performed utilizing a shader component of the 3-D graphics pipeline 108.
Once the graphics data is processed, it is saved in a frame buffer 112 in the form of output packets 110 that are adapted for being depicted on a display 114. It should be noted that the location in which the graphics data is stored is based on instructions 109 associated with the 3-D graphics pipeline 108.
One of the key advantages of this graphics system 100 is that processing for graphics data can “loop.” In one context, a first loop 115 may be employed to process graphics data during multiple instances in a single processing pass in the 3-D graphics pipeline 108. In particular, the processing can loop many times and use a variety of math operations to blend texture and color data, and to compute new texture coordinates, allowing a much more complicated and visually rich resulting image. Still yet, during a second loop 116, the graphics data resulting from one processing pass in the 3-D graphics pipeline 108 can influence the processing of graphics data in a subsequent pass in the 3-D graphics pipeline 108.
In any case, the number of output packets 110 that may be output and saved to the frame buffer 112 is limited to one, during the course of a single pass in current graphics pipeline implementations. This feature inherently limits the amount of graphics data that may be processed and, more importantly, saved to the frame buffer 112 in a single pass.
There is thus a need for a technique of storing multiple output packets of processed graphics data to a frame buffer in a single pass.
A system and method are provided for generating multiple output packets in a single processing pass of a shader in a hardware graphics pipeline. Initially, graphics data is received, after which it is processed utilizing the shader of the hardware graphics pipeline to generate a plurality of output packets. The plurality of output packets is outputted from the shader of the hardware graphics pipeline in the single processing pass.
In one embodiment, the plurality of output packets may be stored in a plurality of defined buffers in memory. As an option, the plurality of defined buffers may be identified utilizing tags associated with the plurality of output packets. Further, the plurality of output packets may be stored in the defined buffers in accordance with a predetermined time slot.
In another embodiment, the plurality of output packets may be each associated with a corresponding primitive, a PC packet, an object, a previous output packet, etc. Still yet, the plurality of output packets may include floating point values, vectors, etc.
In still another embodiment, the output packets may be fed back to the shader during the single processing pass for further processing. Such plurality of output packets may further be output to memory positioned on a semiconductor platform on which the shader is positioned. Moreover, the plurality of output packets may be output to memory positioned externally from a semiconductor platform on which the shader is positioned.
As an option, the plurality of output packets may be output to the memory utilizing x-values and y-values corresponding to a pixel associated with the graphics data. Further, the shader may be programmable for allowing the plurality of output packets to be output to different memory. Still yet, the plurality of output packets may be conditionally output to memory based on a test.
As a further option, a format of the plurality of output packets may match a format of the defined buffers. Further, the plurality of output packets may be read as textures by the shader.
Prior Art FIG. 1 illustrates a graphics system equipped with pixel shading capabilities.
In the context of the present description, the shader 207 may include any module, logic, etc. that is capable of carrying out shading operations on the graphics data. More exemplary information regarding an optional embodiment of the shader 207 will be set forth in greater detail during reference to FIG. 3 .
Once the graphics data is processed, it is saved in memory (i.e. frame buffer 212) in the form of output packets 210 that are adapted for being depicted on a display 214. Still yet, each of the plurality of output packets 210 may or may not be associated with a corresponding primitive, a PC packet, an object, a previous output packet, etc. In any case, the plurality of output packets may include floating point values, vectors, or any desired graphics data resulting from the processing by the 3-D graphics pipeline 208 that relates to at least one pixel.
An aspect of the present embodiment is that the number of output packets 210 to be output and saved to the frame buffer 212 during a single graphics processing pass may be more than one. A benefit of such functionality is that it overcomes many limits in the amount of graphics data that may be processed and saved to memory in a single pass.
In use, the location in which the graphics data is stored is based on instructions 209 associated with the 3-D graphics pipeline 108. As an option, the present graphics system 200 may be capable of looping the processing of graphics data. For use during writing to memory, a plurality of byte masks may optionally be generated by the shader 207.
It should be understood that the plurality of output packets 210 may be output to memory positioned on a semiconductor platform on which the shader 207 is positioned. In the present description, the semiconductor platform may refer to a sole unitary semiconductor-based integrated circuit or chip. It should be noted that the term semiconductor platform may also refer to multi-chip modules with increased connectivity which simulate on-chip operation, and make substantial improvements over utilizing a conventional packaged chip to printed-circuit-board interconnect.
For example, the memory may be positioned on a hardware graphics accelerator integrated circuit including the shader 207. In the alternative, the plurality of output packets 210 may be output to memory positioned externally from a semiconductor platform on which the shader 207 is positioned. For instance, the memory may be shared between a hardware graphics accelerator integrated circuit including the shader 207, and a central processing unit (CPU).
As an option, the output packets may be stored in a plurality of discrete defined buffers in memory, where a format of the output packets may match a format of the defined buffers. For example, such formats may include 4-byte, 8-byte, and/or 16-byte formats. It should be noted that the different buffers may be uniquely formatted to accommodate the associated output packets.
For example, the format may include a quadruplet of color values (i.e. A, B, G, R). Still yet, several output packets may be provided, each containing a color value or position vector. Moreover, the output packets may include packed sub-output packets (i.e. four 8-bit colors packed into a 32-bit data type, with four such 32-bit data types forming an output packet, etc.).
As a further option, such defined buffers may be identified utilizing tags (i.e. identifiers, etc.) associated with the plurality of output packets. Memory addresses may even be calculated from such tags in any desired manner.
Further, the output packets may be stored in the defined buffers in accordance with a predetermined time slot. In such embodiment, buffers may receive output packets as a function of a time slot in which the output packet is outputted, or some other timing scheme.
Still yet, the plurality of output packets 210 may optionally be output to the memory utilizing x-values and y-values corresponding to a pixel associated with the graphics data. Specifically, the location in memory where the output packets 210 are stored may vary as a function of the x-values and the y-values.
In a culling embodiment, the plurality of output packets 210 may be conditionally output to memory based on a test involving a z-value associated with the graphics data. In one embodiment, such test may involve reading a stored z-value associated with at least one pixel of the graphics data. Thereafter, it may be determined whether the stored z-value is in front of a primitive z-value. Output packets may then be conditionally output to memory based on this determination.
For feedback purposes, the plurality of output packets may be read as textures or by other techniques using the shader 207. More information regarding one exemplary way the shader 207 may operate will now be set forth.
As shown, the shader system 300 of the present embodiment includes a rasterizer 350 capable of processing graphics data for generating primitive-based information and pixel-based quads (i.e. groups of pixels). For example, the rasterizer 350 may generate pixel coverage and parameters that may be used by the shader module 352. This processed graphics data is fed to a shader module 352 including a plurality of components.
In particular, the shader module 352 includes a gatekeeper module 358 which, in turn, includes a first instruction processor unit (IPU) 360. Coupled to the gatekeeper module 358 is a first set of computation units 362. Associated therewith is a second set of computation units 364 which is also equipped with a second IPU 366. The shader module 352 is further equipped with a plurality of registers 368.
Associated with the shader module 352 is a texture module 351 which is adapted to retrieve instructions and textures from memory 356 (i.e. frame buffer). Operating in parallel with the shader module 352 is a z-pipeline 369 that is capable of conducting various tests involving the z-values of the graphics data. Both the shader module 352 and the z-pipeline 369 feed into a raster processor (ROP) 354.
In use, the graphics data is received from the rasterizer 350 by the gatekeeper module 358 of the shader module 352. Instructions associated with a shader program are then processed by the first IPU 358 in order to determine the manner in which the graphics data is to be processed by the shader module 352. A first portion of such processing is carried out by the first set of computation units 362. The results of such processing and the instructions are then used by the texture module 351 for retrieving additional information (i.e. instructions, textures, other graphics data, etc.) from the memory 356.
The results of the first portion of processing and/or the information retrieved via the texture module 351 may then be processed by the second set of computation units 364, in accordance with the processing of instructions of the second IPU 366. The results of such second portion of processing may then be output to the ROP 354 or looped 367 for additional processing in the foregoing manner. When looped, previous results may be used at least in part to retrieve additional information using the texture module 351. Thus, the instructions may be used to process texels, pixels, and/or primitives, etc. in a very flexible manner. In any case, the processing results in output packets (i.e. any desired graphics data resulting from the processing).
When the output packets resulting from the processing are ready for output, they may be stored to memory. As mentioned earlier, the plurality of output packets may be each associated with a corresponding primitive, a PC packet, an object, a previous output packet, etc. FIG. 4 illustrates an example of a PC packet system 400, in accordance with one embodiment. As shown, the PC packet system 400 includes a PC packet 404 that precedes and identifies graphics data 402. In particular, the PC packet 404 may include a packet of data that flows through a shader, configuring it to execute a subsequent instruction. Specifically, such packet of data may include a location in a program [i.e. thus serving as a program counter (PC) packet].
As an option, the present shader system 300 may store intermediate graphics data (i.e. colors, other values, etc.) that are generated during a rendering pass in a first-in first-out (FIFO) buffer as the graphics data exits the shader system 300. On a subsequent pass, the contents of the FIFO buffer may be fed into the top of the pipeline. This FIFO buffer may be referred to as a fragment-stream buffer (F-buffer), because this approach may have the effect of associating intermediate results with particular rasterization fragments, rather than with an (x,y) location in a frame buffer. Each rendering pass may use the same viewpoint and geometry, but a different pipeline configuration. More information on such F-buffer may be found with reference to William R. Mark, Kekoa Proudfoot. “The F-Buffer: A Rasterization-Order FIFO Buffer for Multi-Pass Rendering.” In Proceedings of SIGGRAPH/Eurographics Workshop on Graphics Hardware 2001, which is incorporated herein by reference.
In any case, a plurality of such output packets may be stored to memory in a single pass. Such output packets may be stored in separate locations in a frame buffer and addressed in a manner that allows subsequent retrieval during different rendering passes.
It should be noted that the method 500 shown in FIG. 5 represents a single pass. Of course, the present method 500 may be carried out multiple times in a multiple-pass system, where each pass is controlled by separate or different instances of a shader program.
In operation 502, at least one instruction of a certain portion of a program is received. Next, in operation 504, operands identified by the at least one instruction are fetched. Further, if the current pass is after a first pass, the memory associated with one or more previously-processed output packets may be identified for feeding the plurality of output packets back to the shader.
Next, in operation 506, operations associated with the at least one instruction of the program are executed in order to generate one or more output packet(s) in a single processing pass of the shader utilizing the zero, one or more fed back output packets. It should be noted that such operations may include vector operations. With the current output packet(s) generated, it is then determined in decision 508 as to whether such output packet(s) are to be stored in on-chip registers or in a frame buffer.
If it is determined in decision 508 that the current output packet(s) are to be stored in on-chip registers, this is accomplished in operation 510. On the other hand, if it is determined in decision 508 that the current output packet(s) are to be stored in the frame buffer, this is accomplished in operation 512.
Finally, it is determined whether any additional instructions exist in decision 514. If so, the method 500 begins again at operation 502.
While various embodiments have been described above, it should be understood that they have been presented by way of example only, and not limitation. Thus, the breadth and scope of a preferred embodiment should not be limited by any of the above described exemplary embodiments, but should be defined only in accordance with the following claims and their equivalents. The order of elements within claims does not indicate any particular order of steps or operations.
Claims (28)
1. A method for generating multiple output packets in a single processing pass of a shader in a hardware graphics pipeline, comprising:
receiving graphics data;
processing the graphics data utilizing the shader of the hardware graphics pipeline to generate a plurality of output packets;
outputting the plurality of output packets from the shader of the hardware graphics pipeline in the single processing pass; and
feeding back the plurality of output packets to the shader during the single processing pass for further processing.
2. The method as recited in claim 1 , wherein the plurality of output packets are stored in a plurality of defined buffers in memory.
3. The method as recited in claim 2 , wherein the plurality of defined buffers is identified utilizing tags associated with the plurality of output packets.
4. The method as recited in claim 3 , wherein a memory address is calculated from each tag.
5. The method as recited in claim 2 , wherein the plurality of output packets are stored in the defined buffers in accordance with a predetermined time slot.
6. The method as recited in claim 2 , wherein a format of the plurality of output packets matches a format of the defined buffers.
7. The method as recited in claim 2 , wherein the plurality of output packets are read as textures.
8. The method as recited in claim 7 , wherein the plurality of output packets are read as textures by the shader.
9. The method as recited in claim 2 , wherein the defined buffers are uniquely formatted to accommodate associated output packets.
10. The method as recited in claim 1 , wherein the plurality of output packets are each associated with a corresponding primitive.
11. The method as recited in claim 1 , wherein the plurality of output packets are each associated with a corresponding PC packet.
12. The method as recited in claim 1 , wherein the plurality of output packets are each associated with a corresponding object.
13. The method as recited in claim 1 , wherein the plurality of output packets are associated with previous output packets.
14. The method as recited in claim 13 , wherein the previous output packets are used for retrieving additional information from memory including instructions and textures.
15. The method as recited in claim 1 , wherein the plurality of output packets include floating point values.
16. The method as recited in claim 1 , wherein the plurality of output packets include vectors.
17. The method as recited in claim 1 , wherein the plurality of output packets are output to memory positioned on a semiconductor platform on which the shader is positioned.
18. The method as recited in claim 1 , wherein the plurality of output packets are output to memory positioned externally from a semiconductor platform on which the shader is positioned.
19. The method as recited in claim 18 , wherein the plurality of output packets are output to the memory utilizing x-values and y-values corresponding to a pixel associated with the graphics data.
20. The method as recited in claim 18 , wherein the memory is shared by a central processing unit.
21. The method as recited in claim 1 , wherein the shader is programmable for allowing the plurality of output packets to be output to different memories.
22. The method as recited in claim 21 , wherein the different memory includes a first memory positioned on a semiconductor platform on which the shader is positioned, and a second memory positioned externally from the semiconductor platform on which the shader is positioned.
23. The method as recited in claim 1 , wherein the plurality of output packets are conditionally output to memory based on a test.
24. The method as recited in claim 23 , wherein the test includes determining whether a stored Z value associated with at least one pixel of the graphics data is in front of a primitive Z value.
25. A system for generating multiple output packets in a single processing pass, comprising:
a shader of a hardware graphics pipeline for processing graphics data to generate a plurality of output packets in the single processing pass; and
memory coupled to the shader, the memory adapted for storing the plurality of output packets from the shader of the hardware graphics pipeline;
wherein the plurality of output packets are fed back to the shader during the single processing pass for further processing.
26. A system for generating multiple output packets in a single processing pass, comprising:
shader means for processing graphics data to generate a plurality of output packets in the single processing pass; and
memory adapted for storing the plurality of output packets;
wherein the plurality of output packets are fed back to the shader means during the single processing pass for further processing.
27. A method for storing multiple output packets of a shader in a hardware graphics pipeline, comprising:
processing graphics data utilizing the shader of the hardware graphics pipeline to generate a plurality of output packets;
storing the plurality of output packets to memory positioned externally from a semiconductor platform on which the shader is positioned; and
feeding back the plurality of output packets to the shader during the single processing pass for further processing.
28. A method for generating multiple output packets in a single processing pass of a shader in a hardware graphics pipeline, comprising:
receiving graphics data in the hardware graphics pipeline;
during a first pass, executing a first portion of a program in the shader of the hardware graphics pipeline by:
receiving at least one instruction of the first portion of the program,
fetching operands identified by the at least one instruction of the first portion of the program,
executing operations associated with the at least one instruction of the first portion of the program in order to generate a plurality of output packets in the single processing pass of the shader,
identifying a memory corresponding with a destination associated with the at least one instruction of the first portion of the program, and
storing the plurality of output packets to the memory; and
during a second and subsequent passes, executing a second portion of the program in the shader of the hardware graphics pipeline by:
receiving at least one instruction of the second portion of the program,
fetching operands associated with the at least one instruction of the second portion of the program,
identifying the memory associated with the plurality of output packets for feeding the plurality of output packets back to the shader,
executing operations associated with the at least one instruction of the second portion of the program in order to generate at least one additional output packet in another single processing pass of the shader utilizing the fed back plurality of output packets,
identifying a memory corresponding with a destination associated with the at least one instruction of the second portion of the program, and
storing the at least one additional output packet to the memory;
wherein the plurality of output packets are fed back to the shader during at least one of the single processing passes for further processing.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| US10/430,629 US6975321B1 (en) | 2003-05-05 | 2003-05-05 | System and method for generating multiple outputs in a single shader processing pass in a hardware graphics pipeline |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| US10/430,629 US6975321B1 (en) | 2003-05-05 | 2003-05-05 | System and method for generating multiple outputs in a single shader processing pass in a hardware graphics pipeline |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| US6975321B1 true US6975321B1 (en) | 2005-12-13 |
Family
ID=35452578
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| US10/430,629 Expired - Lifetime US6975321B1 (en) | 2003-05-05 | 2003-05-05 | System and method for generating multiple outputs in a single shader processing pass in a hardware graphics pipeline |
Country Status (1)
| Country | Link |
|---|---|
| US (1) | US6975321B1 (en) |
Cited By (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20070055967A1 (en) * | 1997-05-08 | 2007-03-08 | Poff Thomas C | Offload system, method, and computer program product for port-related processing |
| US7450123B1 (en) * | 2001-08-31 | 2008-11-11 | Nvidia Corporation | System and method for render-to-texture depth peeling |
| US7663621B1 (en) * | 2006-11-03 | 2010-02-16 | Nvidia Corporation | Cylindrical wrapping using shader hardware |
| US7697008B1 (en) | 1999-12-06 | 2010-04-13 | Nvidia Corporation | System, method and article of manufacture for a programmable processing model with instruction set |
| US7755634B1 (en) | 1999-12-06 | 2010-07-13 | Nvidia Corporation | System, method and computer program product for branching during programmable vertex processing |
| US7825935B1 (en) * | 2001-11-30 | 2010-11-02 | Nvidia Corporation | System, method and computer program product for using textures as instructions for graphics processing |
| US8269768B1 (en) | 1998-07-22 | 2012-09-18 | Nvidia Corporation | System, method and computer program product for updating a far clipping plane in association with a hierarchical depth buffer |
| US20150022675A1 (en) * | 2008-08-19 | 2015-01-22 | Digimarc Corporation | Image processing architectures and methods |
Citations (11)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US6236413B1 (en) * | 1998-08-14 | 2001-05-22 | Silicon Graphics, Inc. | Method and system for a RISC graphics pipeline optimized for high clock speeds by using recirculation |
| US6259460B1 (en) * | 1998-03-26 | 2001-07-10 | Silicon Graphics, Inc. | Method for efficient handling of texture cache misses by recirculation |
| US6392655B1 (en) * | 1999-05-07 | 2002-05-21 | Microsoft Corporation | Fine grain multi-pass for multiple texture rendering |
| US20030020741A1 (en) * | 2001-07-16 | 2003-01-30 | Boland Michele B. | Systems and methods for providing intermediate targets in a graphics system |
| US6593923B1 (en) | 2000-05-31 | 2003-07-15 | Nvidia Corporation | System, method and article of manufacture for shadow mapping |
| US20040003370A1 (en) * | 2002-03-08 | 2004-01-01 | Electronic Arts Inc. | Systems and methods for implementing shader-driven compilation of rendering assets |
| US6690372B2 (en) | 2000-05-31 | 2004-02-10 | Nvidia Corporation | System, method and article of manufacture for shadow mapping |
| US6690672B1 (en) | 1999-04-05 | 2004-02-10 | Avaya Inc. | Method and apparatus for placing an intelligent telephone call using an internet browser |
| US6760033B2 (en) * | 1999-04-19 | 2004-07-06 | Microsoft Corporation | Combined floating-point logic core and frame buffer |
| US6809739B2 (en) * | 2002-04-30 | 2004-10-26 | Silicon Graphics, Inc. | System, method, and computer program product for blending textures during rendering of a computer generated image using a single texture as a mask |
| US6819325B2 (en) * | 2000-03-07 | 2004-11-16 | Microsoft Corporation | API communications for vertex and pixel shaders |
-
2003
- 2003-05-05 US US10/430,629 patent/US6975321B1/en not_active Expired - Lifetime
Patent Citations (11)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US6259460B1 (en) * | 1998-03-26 | 2001-07-10 | Silicon Graphics, Inc. | Method for efficient handling of texture cache misses by recirculation |
| US6236413B1 (en) * | 1998-08-14 | 2001-05-22 | Silicon Graphics, Inc. | Method and system for a RISC graphics pipeline optimized for high clock speeds by using recirculation |
| US6690672B1 (en) | 1999-04-05 | 2004-02-10 | Avaya Inc. | Method and apparatus for placing an intelligent telephone call using an internet browser |
| US6760033B2 (en) * | 1999-04-19 | 2004-07-06 | Microsoft Corporation | Combined floating-point logic core and frame buffer |
| US6392655B1 (en) * | 1999-05-07 | 2002-05-21 | Microsoft Corporation | Fine grain multi-pass for multiple texture rendering |
| US6819325B2 (en) * | 2000-03-07 | 2004-11-16 | Microsoft Corporation | API communications for vertex and pixel shaders |
| US6593923B1 (en) | 2000-05-31 | 2003-07-15 | Nvidia Corporation | System, method and article of manufacture for shadow mapping |
| US6690372B2 (en) | 2000-05-31 | 2004-02-10 | Nvidia Corporation | System, method and article of manufacture for shadow mapping |
| US20030020741A1 (en) * | 2001-07-16 | 2003-01-30 | Boland Michele B. | Systems and methods for providing intermediate targets in a graphics system |
| US20040003370A1 (en) * | 2002-03-08 | 2004-01-01 | Electronic Arts Inc. | Systems and methods for implementing shader-driven compilation of rendering assets |
| US6809739B2 (en) * | 2002-04-30 | 2004-10-26 | Silicon Graphics, Inc. | System, method, and computer program product for blending textures during rendering of a computer generated image using a single texture as a mask |
Non-Patent Citations (12)
| Title |
|---|
| "NVIDIA OpenGL Extension Specifications", NVIDIA Coporation, Jun. 10, 2003. |
| "NVIDIA OpenGL Extension Specifications", NVIDIA Corporation, Nov. 26, 2001. |
| C. Wittenbrink. R-Buffer: A Pointerless A-Buffer Hardware Architecture. In Proceedings of The ACM SIGGRAPH/Eurographics Workshop on Graphics Hardware (2001), pp. 73-80. * |
| E. Chan, R. Ng, P. Sen, K. Proudfoot, and P. Hanrahan. Effient Partitioning Of Fragment Shaders For Multipass Rendering O Programmable Graphics Hardware. In SIGGRAPH/EUROGRAPHICS Workshop On Graphics Hardware (2002), pp. 69-78. * |
| E. Lindholm, M. Kilgard, and H. Moreton. A User-Programmable Vertex Engine. In ACM SIGGRAPH 2001, pp. 140-158. * |
| http://developer.nvidia.com/object/Filter<SUB>-</SUB>Blitting.html, May 10, 2001. |
| K. Proudfoot, W. Mark, S. Tzvetkov, and P. Hanrahan. A Real-Time Procedural Shading System for Programmable Graphics Hardware. In ACM SIGGRAPH 2001, pp. 159-170. * |
| M. McCool and W. Heidrich. Texture Shaders. In Proceedings of the ACM SIGGRAPH/Eurographics Workshop on Graphics Hardware (1999), pp. 117-126. * |
| M. Olano and A. Lastra. A Shading Language on Graphics Hardware: The PixelFlow Shading System. In Proceedings of SIGGRAPH 1998, pp. 1-10. * |
| M. Peercy, M Olano, J. Airey, and P. Ungar. Interactive Multi-Pass Programmable Shading. In Proceedings of The 27th Annua Conference on Computer Graphics and Interactive Techniques (Jul. 2000), pp. 425-432. * |
| W. Mark and K. Proudfoot. Compiling to a VLIW Fragement Pipeline. In Proceedings of 2001 SIGGRAPH/Eurographics Workshop on Graphics Hardware, pp. 47-55. * |
| William R. Mark et al., "The F-Buffer: A Rasterization-Order FIFO Buffer for Multi-Pass Rendering", SIGGRAPH/Eurographics Graphics Hardware Workshop 2001. |
Cited By (12)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20070055967A1 (en) * | 1997-05-08 | 2007-03-08 | Poff Thomas C | Offload system, method, and computer program product for port-related processing |
| US8269768B1 (en) | 1998-07-22 | 2012-09-18 | Nvidia Corporation | System, method and computer program product for updating a far clipping plane in association with a hierarchical depth buffer |
| US7697008B1 (en) | 1999-12-06 | 2010-04-13 | Nvidia Corporation | System, method and article of manufacture for a programmable processing model with instruction set |
| US7755636B1 (en) | 1999-12-06 | 2010-07-13 | Nvidia Corporation | System, method and article of manufacture for a programmable processing model with instruction set |
| US7755634B1 (en) | 1999-12-06 | 2010-07-13 | Nvidia Corporation | System, method and computer program product for branching during programmable vertex processing |
| US8259122B1 (en) | 1999-12-06 | 2012-09-04 | Nvidia Corporation | System, method and article of manufacture for a programmable processing model with instruction set |
| US8264492B1 (en) | 1999-12-06 | 2012-09-11 | Nvidia Corporation | System, method and article of manufacture for a programmable processing model with instruction set |
| US7450123B1 (en) * | 2001-08-31 | 2008-11-11 | Nvidia Corporation | System and method for render-to-texture depth peeling |
| US7825935B1 (en) * | 2001-11-30 | 2010-11-02 | Nvidia Corporation | System, method and computer program product for using textures as instructions for graphics processing |
| US7663621B1 (en) * | 2006-11-03 | 2010-02-16 | Nvidia Corporation | Cylindrical wrapping using shader hardware |
| US20150022675A1 (en) * | 2008-08-19 | 2015-01-22 | Digimarc Corporation | Image processing architectures and methods |
| US9204038B2 (en) * | 2008-08-19 | 2015-12-01 | Digimarc Corporation | Mobile device and method for image frame processing using dedicated and programmable processors, applying different functions on a frame-by-frame basis |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US7570266B1 (en) | Multiple data buffers for processing graphics data | |
| EP1399892B1 (en) | Programmable pixel shading architecture | |
| US7423644B2 (en) | Method and apparatus for dual pass adaptive tessellation | |
| US7218291B2 (en) | Increased scalability in the fragment shading pipeline | |
| US6268875B1 (en) | Deferred shading graphics pipeline processor | |
| US6771264B1 (en) | Method and apparatus for performing tangent space lighting and bump mapping in a deferred shading graphics processor | |
| US7042462B2 (en) | Pixel cache, 3D graphics accelerator using the same, and method therefor | |
| US8610729B2 (en) | Floating point computer system with fog | |
| US8063900B1 (en) | GPU assisted 3D compositing | |
| US6989840B1 (en) | Order-independent transparency rendering system and method | |
| US6744433B1 (en) | System and method for using and collecting information from a plurality of depth layers | |
| US7616202B1 (en) | Compaction of z-only samples | |
| US6791561B1 (en) | Method and apparatus for rendering video data | |
| US6456291B1 (en) | Method and apparatus for multi-pass texture mapping | |
| US6975321B1 (en) | System and method for generating multiple outputs in a single shader processing pass in a hardware graphics pipeline | |
| US6778189B1 (en) | Two-sided stencil testing system and method | |
| US7109999B1 (en) | Method and system for implementing programmable texture lookups from texture coordinate sets | |
| Assarsson et al. | Occlusion culling and z-fail for soft shadow volume algorithms | |
| US20230043630A1 (en) | Graphics processing systems | |
| Georgii et al. | Interactive collision detection for deformable and GPU objects | |
| US7825935B1 (en) | System, method and computer program product for using textures as instructions for graphics processing |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| AS | Assignment |
Owner name: NVIDIA CORPORATION, CALIFORNIA Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:LINDHOLM, JOHN ERIK;MOLNAR, STEVEN E.;ZATZ, HAROLD ROBERT FELDMAN;REEL/FRAME:014053/0301;SIGNING DATES FROM 20030502 TO 20030505 |
|
| STCF | Information on status: patent grant |
Free format text: PATENTED CASE |
|
| FPAY | Fee payment |
Year of fee payment: 4 |
|
| FPAY | Fee payment |
Year of fee payment: 8 |
|
| FPAY | Fee payment |
Year of fee payment: 12 |