Source: http://www.docstoc.com/docs/76964490/Method-And-System-For-Defining-And-Controlling-Algorithmic-Elements-In-A-Graphics-Display-System---Patent-7884817
Timestamp: 2014-09-30 18:27:22
Document Index: 32938971

Matched Legal Cases: ['art/9612', 'art4', 'art/9606', 'art4', 'art/9606', 'art5', 'art/9606', 'art6', 'art/9606', 'art7', 'art/9606', 'art8', 'art 2']

Method And System For Defining And Controlling Algorithmic Elements In A Graphics Display System - Patent 7884817
United States Patent: 7884817
7,884,817
Method and system for defining and controlling algorithmic elements in a
An API is provided that enables programmability of a 3D chip, wherein
programming or algorithmic elements written by the developer can be
downloaded to the chip, thereby programming the chip to perform those
algorithms. A developer writes a routine that is downloadable to a 3D
graphics chip. There are also a set of algorithmic elements that are
provided in connection with the API that have already been programmed for
the developer, that are downloadable to the programmable chip for
improved performance. Thus, a developer may download preexisting API
objects to a 3D graphics chip. A developer adheres to a specific format
for packing up an algorithmic element, or set of instructions, for
implementation by a 3D graphics chip. The developer packs the instruction
set into an array of numbers, by referring to a list of `tokens`
understood by the 3D graphics chip. This array of numbers in turn is
mapped correctly to the 3D graphics chip for implementation of the
algorithmic element by the 3D graphics chip.
Boyd; Charles N. (Woodinville, WA), Toelle; Michael A. (Bellevue, WA)
10/934,274
09796577Mar., 20017159041
60187535Mar., 2000
345/418  ; 345/419
345/418-419,581,619
Mills, Jr. et al.
Mirapuri et al.
5793386
Montrym et al.
6578197
7782316
2004/0201590
2005/0052456
2010/0039430
Chin et al., The OpenGL Graphics System Utility Library (Version 1.3), Nov. 1998. cited by examiner
Corrie, B. et al., &quot;Data Shaders,&quot; Proceedings Visulaization &#39;93, San Jose, CA, Oct. 25-29, 1993, 275-282. cited by other
Glazzard, N. et al., &quot;Implementing a Shading Language,&quot; Computer Graphics 90, London, UK, Nov. 6-8, 1990, 111-121. cited by other
Hanrahan, P. et al., &quot;A Language for Shading and Lighting Calculations,&quot; Computer Graphics, 1990, 24(4), 289-298. cited by other
Leech, J., &quot;OpenGL Extensions and Restrictions for PixelFlow,&quot; The University of North Caroline at Chapel Hill, 1995, 1-39. cited by other
Molnar, S. et al., &quot;PixelFlow: High-Speed Rendering Using Image Composition,&quot; Computer Graphics, 26(2), 231-240. cited by other
Molnar, S. et al., &quot;PixelFlow: The Continuing Saga,&quot; 1995 Parallel Rendering Symposium, Atlanta, GA, Oct. 30-31, 1995, p. 79. cited by other
Molnar, S., &quot;The PixelFlow Texture and Image Subsystem,&quot; Computers &amp; Graphics, 1996, 20(4), 491-502. cited by other
Olano, M., &quot;A Programmable Pipeline for Graphics Hardware,&quot; PhD Dissertation, Department of Computer Science, University of North Carolina at Chapel Hill, 1998, 1-168. cited by other
Olano, M. et al., &quot;Procedural Primitives in a High Performance, Hardware Accelerated, Z-Buffer Renderer,&quot; UNC Computer Science Technical Report 97-040, Department of Computer Science, University of North Carolina, Chapel Hill, North Carolina, 1997,
Olano, M. et al., &quot;A Shading Language on Graphics Hardware: The PixelFlow Shading System,&quot; Proceedings of SIGGRAPH 98, Orlando, Florida, Jul. 19-24, 1998, 1-10. cited by other
Pountain, D., &quot;PixelFlow--Scalable Image Processing--It Divides and Conquers Rendering by Drawing the Objects First, Then Combining Them,&quot; Byte, 1995, 20(11), 6 pages. cited by other
Proudfoot, K. et al., &quot;A Real-Time Procedural Shading System for Programmable Graphics Hardware,&quot; Computer Graphics Proceedings, SIGGRAPH, 2001, 159-170. cited by other
Slusallek, P. et al., &quot;Implementing RenderMan-Practice, Problems and Enhancements,&quot; Eurographics &#39;94, 1994, 13(3), 443-454. cited by other
Abrash, M., &quot;Inside Xbox Graphics,&quot; Dr. Dobb&#39;s J., Aug. 2000, 21-22, 24-26. cited by other
Antinori, F. et al., &quot;Experience with a 30 cm.sup.2 silicon pixel plane in CERN experiment WA97,&quot; Nucl. Instr. Meth. Phys. Res. A., 1995, 360, 91-97. cited by other
Bachstein, W. et al., &quot;Single-Chip erledigt Multimedia,&quot; Elektronik, 1996, 17, 58-62. cited by other
Bajaj, C. et al., &quot;Making 3D Textures Practical,&quot; IEEE: Proceedings-Seventh Pacific Conference on Computer Graphics and Applications, Oct. 5-7, 1999, 259-269. cited by other
Bakalash, R. et al., &quot;A Barrel Shift Microsystem for Parallel Processing,&quot; in MICRO 23 Microprogramming and Microarchitecture, IEEE: Proceedings of the 23.sup.rd Annual Workshop and Symposium, Orlando Florida, Nov. 27-29, 1990, 223-229. cited by
Bankston, J. et al., &quot;Pipeline Processing with Modula-2,&quot; J. Pascal, Ada, &amp; Modula-2, 1986, 5(5), 46-51. cited by other
Biernat, M.J. et al., &quot;Approximate Shadow Generation,&quot; IEEE Montech Conferences, Nov. 9-12, 1987, 97-101. cited by other
Brechbuhler, Ch. et al., &quot;Parametrization of Closed Surfaces for 3-D Shape Description,&quot; Comp. Vision Image Understanding, Mar. 1995, 61(2), 154-170. cited by other
Chen, Li, &quot;Generalization Discrete Object Tracking Algorithms and Implementation,&quot; in Vision Geometry VI, Proceedings of SPIE, Melter, R.A. et al. (eds.), Jul. 28-29, 1997, 3168, 184-195. cited by other
Chiarulli, D.M. et al., &quot;Draft: A Dynamically Reconfigurable Processor for Integer Arithmetic,&quot; IEEE: Proceedings-7.sup.th Symposium on Computer Arithmetic, University of Illinois, Hwang, K. (ed.), Jun. 4-6, 1985, 309-317. cited by other
Cox, M. et al., &quot;Multi-Level Texture Caching for 3D Graphics Hardware,&quot; IEEE: Proceedings-The 25.sup.th Annual International Symposium on Computer Architecture, Barcelona, Spain, Jun. 27-Jul. 1, 1998, 86-97. cited by other
Dietz, P.H. et al., &quot;Simple Networks for Pixel Plane Median Filtering,&quot; IEEE Transactions on Circuits and Systems-II: Analog and Digital Signal Processing, Dec. 1993, 40(12), 799-801. cited by other
Grimes, J. et al., &quot;A New Processor with 3-D Graphics Capabilities,&quot; NCGA &#39;89 Conference Proceedings: 10.sup.th Annual Conference and Exposition Dedicated to Computer Graphics, Philadelphia, Pennsylvania, Apr. 17-20, 1989, vol. 1, 275-284. cited by
Grimes, J. et al., &quot;The Intel i860 64-Bit Processor: A General-Purpose CPU with 3D Graphics Capabilities,&quot; IEEE Computer Graphics and Applications, Jul. 1989, 85-94. cited by other
Gomes, J. et al., &quot;Graphical Objects,&quot; The Visual Computer, 1996, 12, 269-282. cited by other
Gordon, R.L., Ph.D. et al., Window Management, Graphics, and Operating Systems, Operating Systems Review, Jul. 1987, 21(3), 5-8. cited by other
Goris, A. et al., &quot;A Configurable Pixel Cache for Fast Image Generation,&quot; IEEE Computer Graphics and Applications, Mar. 1987, 24-32. cited by other
Haig, T., &quot;How to program in machine language,&quot; Electronics, Aug. 1982, 94-96, 98, 100-103. cited by other
Harrison, J.P. et al., &quot;The Role of Microcomputers in Interactive Graphical Planning,&quot; Engin. Software for Microcomputers, Proc., Apr. 1984, 631-641. cited by other
Ho, C-H et al., &quot;Efficient Point-Based Rendering Techniques for Haptic Display of Virtual Objects,&quot; Presence, Oct. 1999, 8(5), 477-491. cited by other
Hoffman, C. et al., &quot;Automatic Surface Generation in Computer Aided Design,&quot; supported by the National Science Foundation, Department of Computer Science, Cornell University, Ithaca, New York, Jan. 1985, 1-22. cited by other
Hummel, R., &quot;Render Benders: 26 Graphics Cards for Fast 3-D,&quot; Byte, Mar. 1998, 112-119. cited by other
James, M., &quot;3-D graphics to become accessible to all,&quot; Scientific Computing World, Feb. 1997, 41 and 43. cited by other
Johnson, S.P., &quot;Direct3D Revealed: Microsoft&#39;s 3-D API provides device-independent access to acceleration hardware. Here&#39;s how it works,&quot; Core Technologies, http://byte.com/art/9612/sec5/art4.htm, Dec. 1996, 5 pages. cited by other
Jones, M. et al., &quot;High-Performance Graphics Via Silicon Compilation,&quot; VLSI Systems Design, Mar. 1987, 32, 33, 36 and 38. cited by other
Kaya, E.M., &quot;New Trends in Graphic Display System Architecture,&quot; in Frontiers in Computer Graphics, Proceedings of Computer Graphics, Tokyo &#39;84, Kunii, T.L. (ed.), 1985, 310-320. cited by other
Kumar, S. et al., &quot;Efficient rendering of trimmed NURBS surfaces,&quot; Computer-Aided Disign, Jul. 1995, 27(7), 509-521. cited by other
Labsik, U. et al., &quot;Progressive transmission of subdivision surfaces,&quot; Computational Geometry, 2000, 15, 25-39. cited by other
Lachaud, J-O. et al., &quot;Continuous Analogs of Digital Boundaries: A Topological Approach to Iso-Surfaces,&quot; Graphical Models, 2000, 62, 129-164. cited by other
Lapidous, E. et al., &quot;Optimal Depth Buffer for Low-Cost Graphics Hardware,&quot; Trident Microsystems, Inc., 1999, 67-73. cited by other
Lastra, A. et al., &quot;Real-Time Programmable Shading,&quot; Proceedings: 1995 Symposium on Interative 3D Graphics, Monterey, California, Apr. 9-12, 1995, 59-66. cited by other
Lee, J-A. et al., &quot;SPARP: a single pass antialiased rasterization processor,&quot; Comput. &amp; Graphics, 2000, 24, 233-243. cited by other
Lichten, L., &quot;A Solution to Surface Connectivity Problems in Computer-Aided Design,&quot; Computer Graphics, Mar. 1981, 14(4), 168-199. cited by other
McManus, D. et al., &quot;Optimal Static 2-Dimensional Screen Subdivision for Parallel Rasterization Architectures,&quot; Comput. &amp; Graphics, 1997, 21(2), 159-169. cited by other
Mabin, F.H. et al., &quot;A Parallel Algorithm to Reconstruct Bounding Surfaces in 3D Images,&quot; J. Supercomputing, 1998, 12, 137-155. cited by other
Meyers, D. et al., &quot;Surfaces from Contours,&quot; ACM Transactions on Graphics, Jul. 1992, 11(3), 228-258. cited by other
Micikevicius, P. et al., &quot;Teaching a Computer Graphics Class Using DirectX,&quot; J. Comput. in Small Colleges; Proceedings of the Ninth Annual CCSC South Central Conference, (Jackson, Mississippi, Apr. 17-18), Meinke, J.G. (ed.), Mar. 1998, 13(4),
61-66. cited by other
Nishimura, H. et al., &quot;A Multicomputer System Links: Its Architecture and Graphics Applications,&quot; IECON &#39;84: International Conference on Industrial Electronics, Control and Instrumentation, Tokyo, Japan, Oct. 22-26, 1984, 1, 270-274. cited by other
Ohhashi, M. et al., &quot;A 32b 3-D Graphic Processor Chip with 10M Pixels/s Gouraud Shading,&quot; 1988 IEEE International Solid-State Circuits Conference Digest of Technical Papers, Feb. 1988, 168-169 and 352. cited by other
Ohbuchi, R. et al., &quot;Embedding Data in 3D Models,&quot; in Interactive Distributed Multimedia Systems and Telecommunication Services, 4.sup.th International Workshop, IDMS &#39;97, Darmstadt, Germany, Sep. 10-12, 1997, 1-10. cited by other
Rowlan, J.S. et al., &quot;A distributed, parallel, interactive volume rendering package,&quot; IEEE: Proceedings-Visualization &#39;94, Washington, D.C., Oct. 17-21, 1994, 21-30. cited by other
Schneider, B-O. et al., &quot;An adaptive framework for 3D graphics over networks,&quot; Comput. &amp; Graphics, 1999, 23, 867-874. cited by other
Schneider, B-O. et al., &quot;M-Buffer: A Flexible MISD Architecture for Advanced Graphics,&quot; Comput. &amp; Graphics, 1995, 19(2), 239-246. cited by other
Senthinathan, R. et al., &quot;A 650-MHz, IA-32 Microprocessor with Enhanced Data Streaming for Graphics and Video,&quot; IEEE J. Solid-State Circuits, Nov. 1999, 34(11), 1454-1465. cited by other
Shinya, M., &quot;Improvements on the Pixel-tracing Filter: Reflection/Refraction, Shadows, and Jittering,&quot; Proceedings: Graphics Interface &#39;95, May 7-19, 1995, 92-102. cited by other
Shirali, N.S. et al., &quot;A Parallel Architecture Graphics Processor,&quot; IEEE Southeastcon: Conference Proceedings, Knoxville, Tennessee, Apr. 11-13, 1998, 108-111. cited by other
Smith, D.R. et al., &quot;A Circuit-Switched Shared-Memory Multiprocessor,&quot; International J. Mini Microcomputers, 1995, 17(3), 108-118. cited by other
Sussman, H. et al., &quot;Graphics Memory Architectures,&quot; Wescon/86 Conference Record, 1986, 1-6. cited by other
Swanson, R.W. et al., &quot;A Fast Shaded-Polygon Rendered,&quot; Computer Graphics, Aug. 1986, 20(4), 95-101. cited by other
Thompson, T., &quot;An inside look at the most popular 3-D environments: OpenGL, QuickDraw 3D, and Direct3D,&quot; Must-See 3-D Engines, Jun. 1996, http://byte.com/art/9606/sec11/art4.htm, 7 pages. cited by other
Thompson, T., &quot;Open GL&#39;s Command Structure,&quot; Must-See 3-D Engines, Jun. 1996, http://byte.com/art/9606/sec11/art5.htm, 1 page. cited by other
Thompson, T., &quot;QuickDraw 3D&#39;s Command Structure,&quot; Must-See 3-D Engines, Jun. 1996, http://byte.com/art/9606/sec11/art6.htm, 1 page. cited by other
Thompson, T., &quot;Direct3D&#39;s Engine,&quot; Must-See 3-D Engines, Jun. 1996, http://byte.com/art/9606/sec11/art7.htm, 1 page. cited by other
Thompson, T., &quot;Three Ways to Tackle Multithreading,&quot; Must-See 3-D Engines, Jun. 1996, http://byte.com/art/9606/sec11/art8.htm, 1 page. cited by other
Teonnies, K.D. et al., &quot;Volume rendering for interactive 3-d segmentation,&quot; in Image Display, Proceeding of SPIE, Newport Beach, California, Feb. 23-25, 1997, 3031, 602-609. cited by other
Wilson, J.L. et al., &quot;Designing a Graphics Application Interface,&quot; Proceedings Graphics Interface &#39;85, Montreal, Quebec, May 27-31, 1985, 373-380. cited by other
Yoshida, M. et al., &quot;Trend of the computer graphics hardware,&quot; Information Processing Soc. of Japan, Oct. 1988, 29(10), 1109-1115. cited by other
Zheng, Y. et al., &quot;Three-dimensional unstructured mesh generation: Part 2. Surface meshes,&quot; Comput. Methods Appl. Mech. Engrg., 1996, 134, 269-284. cited by other
Conference Paper, &quot;A Shading and Compositing Processor based on Crossbar Switches and SRAM Memory,&quot; 1999, 4 pages. cited by other
NVIDIA Corporation, &quot;Technical Brief: NVIDIA nForce Platform Processing Architecture,&quot; 2001, 1-9. cited by other
NVIDIA Corporation, &quot;Technical Brief: NVIDIA nfiniteFX II Engine From Research to Real Time,&quot; Jan. 16, 2002, 7 pages. cited by other
NVIDIA Corporation, &quot;System Platform Porcessor (SPP) / Integrated Graphics Processor (IGP): Redefining System and Graphics Performance,&quot; nForce SPP/IGP Product Overview, Jan. 2002, Version 1, 2 pages. cited by other
U.S. Appl. No. 10/971,248: Final Rejection dated Sep. 22, 2009. cited by other
U.S. Appl. No. 10/971,248: Non-Final Rejection dated Feb. 18, 2009. cited by other
U.S. Appl. No. 10/971,248: Notice of Allowance dated Apr. 30, 2010. cited by other
U.S. Appl. No. 10/971,450: Final Rejection dated Sep. 22, 2009. cited by other
U.S. Appl. No. 10/971,450: Non-Final Rejection dated Feb. 18, 2009. cited by other
U.S. Appl. No. 10/971,450: Notice of Allowance dated May 6, 2010. cited by other
U.S. Appl. No. 10/971,484: Final Rejection dated Sep. 15, 2009. cited by other
U.S. Appl. No. 10/971,484: Non-Final Rejection dated Feb. 20, 2009. cited by other
U.S. Appl. No. 10/971,484: Notice of Allowance dated Apr. 29, 2010. cited by other
Segal et al., &quot;The OpenGL Graphics Systems: A Specification (Version 1.2.1)&quot;, Silicon Graphics, Apr. 1, 1999, 1-278. cited by other
U.S. Appl. No. 09/796,577: Final Rejection, Jun. 23, 2005, 10 pages. cited by other
U.S. Appl. No. 09/796,577: Final Rejection, Mar. 27, 2006, 13 pages. cited by other
U.S. Appl. No. 09/796,577: Non-Final Rejection, Aug. 5, 2004, 17 pages. cited by other
U.S. Appl. No. 09/796,577: Non-Final Rejection, Dec. 23, 2005, 10 pages. cited by other
U.S. Appl. No. 09/796,577: Non-Final Rejection, Feb. 24, 2005, 10 pages. cited by other
U.S. Appl. No. 09/796,577: Notice of Allowance, Oct. 5, 2006, 9 pages. cited by other
U.S. Appl. No. 09/796,579: Final Rejection, Aug. 24, 2004, 7 pages. cited by other
U.S. Appl. No. 09/796,579: Non-Final Rejection, Feb. 11, 2004, 9 pages. cited by other
U.S. Appl. No. 09/796,579: Non-Final Rejection, Oct. 2, 2003, 16 pages. cited by other
U.S. Appl. No. 09/796,579: Notice of Allowance, Nov. 12, 2004, 4 pages. cited by other
U.S. Appl. No. 10/961,435: Non-Final Rejection, Dec. 31, 2008, 18 pages. cited by other
U.S. Appl. No. 10/961,435: Non-Final Rejection, Sep. 25, 2009, 12 pages. cited by other
U.S. Appl. No. 10/961,435: Notice of Allowance, Mar. 22, 2010, 19 pages. cited by other.
This application is a divisional of U.S. patent application 09/796,577
filed on Mar. 1, 2001, now U.S. Pat. No. 7,159,041, which claims the
benefit of U.S. Provisional Application Ser. No. 60/187,535 filed on Mar.
7, 2000, which are hereby incorporated by reference in their entirety.
1.  A graphics chip having stored thereon computer-executable instructions, the computer-executable instructions for specifying a declaration array for a procedural shader, the
declaration array setting forth procedural shader instructions accessible by a developer through an application programming interface (API) and comprising: a plurality of DWORDs wherein each of the plurality of DWORDs includes at least one token selected
from a list of tokens that is interpretable by the graphics chip and provides an instruction to be performed by the procedural shader;  and at least an algorithmic element that is an instruction set packed into the plurality of DWORDs by the API and
represents an already programmed algorithm that provides functionality for the procedural shader below or inside the API, the algorithmic element being accessible by a developer via the API and being formed by mapping the plurality of DWORDs to
corresponding locations of the procedural shader for implementing the instructions for the at least one token.
2.  A graphics chip according to claim 1, wherein the plurality of DWORDs is structured as an array.
3.  A graphics chip according to claim 1, wherein the plurality of DWORDs includes data representative of assignments of procedural shader input registers to data stream elements, whereby the assignments bind a specific vertex register to a
single vertex stream element within a vertex stream and wherein a vertex stream element is identified by a byte offset within the stream and a type.
4.  A graphics chip according to claim 3, wherein the type specifies an arithmetic data type and a dimensionality.
5.  A graphics chip according to claim 3, wherein a stream data element that is less than four values is expanded to consist of four values.
6.  A graphics chip according to claim 3, wherein data streams include data which is not loaded into a vertex register, thus allowing data which is not used by the procedural shader to exist in the vertex stream, whereby the skipped data is
defined by a count of DWORDs to skip over.
7.  A graphics chip according to claim 1, wherein the plurality of DWORDs includes data representative of assignments of procedural shader input registers to implicit data from a primitive tessellator, thereby controlling the loading of vertex
data, which is generated during a primitive tessellation process, prior to the vertex data being transmitted to the procedural shader.
8.  A graphics chip according to claim 1, wherein the plurality of DWORDs includes data for loading into constant memory of the procedural shader at the time a procedural shader is set as the current procedural shader.
9.  A graphics chip according to claim 8, wherein each token specifies values for at least one contiguous constant register of the procedural shader, thereby allowing the procedural shader to update an arbitrary subset of the constant memory.
10.  A graphics chip according to claim 1, wherein the at least one token includes at least one of (1) an NOP token wherein an NOP token is ignored during parsing of the declaration array, (2) a stream selector token, (3) a stream data
definition token providing a mapping to vertex input memory, (4) a vertex input memory from tessellator token for use in connection with assigning vertex input memory from a tessellator, (5) a constant memory token for use in connection with loading
constant memory of the procedural shader, (6) an extension token, (7) a reserved token and (8) an end of array token specifying the end of the declaration array.
11.  A graphics chip according to claim 10, wherein the NOP token, the stream selector token, the stream data definition token, the vertex input memory from tessellator token, the reserved token and the end of array token are single DWORD
12.  A graphics chip according to claim 10, wherein streams are allowed to include data which is not loaded into a vertex register, thus allowing data which is not used for the procedural shader to exist in the vertex stream, whereby the skipped
data is defined by a count of DWORDs to skip over.
13.  A graphics chip according to claim 1, wherein the computer-executable instructions further comprise computer-executable instructions for receiving the plurality of DWORDs in respective data containers in parallel.
14.  A graphics chip according to claim 1, wherein the computer-executable instructions further comprise computer-executable instructions for receiving tokens in respective data containers in parallel.
15.  A video card comprising: a video memory that stores input data stream elements;  and a graphics chip having stored thereon computer-executable instructions, the computer-executable instructions for specifying a declaration array for a
procedural shader that processes the input data stream elements, the declaration array setting forth procedural shader instructions accessible by a developer through an application programming interface (API) and comprising: a plurality of DWORDs wherein
each of the plurality of DWORDs includes at least one token selected from a list of tokens that is interpretable by the graphics chip and provides an instruction to be performed by the procedural shader;  and at least an algorithmic element that is an
instruction set packed into the plurality of DWORDs by the API that represents an already programmed algorithm that provides functionality for the procedural shader below or inside the API, the algorithmic element being accessible by a developer via the
API and being formed by mapping the plurality of DWORDs to corresponding locations of the procedural shader for implementing the instructions for the at least one token.
16.  A video card according to claim 15, wherein the plurality of DWORDs is structured as an array.
17.  A video card according to claim 15, wherein the plurality of DWORDs includes data representative of assignments of procedural shader input registers to data stream elements, whereby the assignments bind a specific vertex register to a
18.  A video card according to claim 17, wherein data streams include data which is not loaded into a vertex register, thus allowing data which is not used by the procedural shader to exist in the vertex stream, whereby the skipped data is
19.  A video card according to claim 15, wherein the plurality of DWORDs includes data representative of assignments of procedural shader input registers to implicit data from a primitive tessellator, thereby controlling the loading of vertex
20.  A video card according to claim 15, wherein the computer-executable instructions further comprise computer-executable instructions for receiving the plurality of DWORDs in respective data containers in parallel.
For the vast majority of applications, application programmers rely on or utilize some form of software interface to interact with a computer and its associated devices.  For graphics applications, developers or programmers typically utilize a
graphics software interface, such as a 3D graphics application programming interface (API), to facilitate the interaction with constituent parts of a graphics system.  Programmers typically rely on software interfaces to peripherals and devices so that
they can focus on the specifics of their application rather than on the specifics of controlling a particular device and so that their efforts are not duplicated from application to application.  However, even after generations of software interfaces,
there are certain aspects of today&#39;s software interfaces that do not provide the level of performance desired and thus can be improved.
There are several reasons why previous generation graphics software interfaces do not meet the needs of today&#39;s graphics applications and systems.  One type of resource contention issue that sometimes occurs is due to the demands of multiple
devices and applications requiring graphics system resources simultaneously.  For example, if multiple applications running simultaneously are maintaining connections to multiple surfaces from various objects of the graphics system, sometimes these
connections to surfaces can become severed or disconnected.  When multiple applications have connections between surfaces and objects, more system resources, such as memory space, are utilized resulting in an increased likelihood of a disconnection.  For
instance, while a user may generally toggle back and forth between executing applications, if the connection to surface memory for any one application is severed, a user may have to restart the application or begin certain portions of the application
again in order to recreate a proper connection.  Today&#39;s 3D graphics APIs check for severing of connections in a redundant fashion, wasting computing resources, and consequently there is a need for an improved technique for checking for the persistence
of connections between object space and surface space.
Another reason why previous generation graphics software interfaces are inadequate is that versioning itself can create problems when each version is not rewritten from scratch, as is often the case.  As any software developer has encountered,
the subsequent versioning of a software product to meet the ad hoc needs of an evolving operating environment produces a scenario where once separate or merely related modules may be more efficiently placed together, rewritten or merged.  A software
interface between graphics application developers and rapidly evolving hardware is no less a product.  For example, graphics APIs have undergone multiple evolutions to arrive at the current state of the art of graphical software interfacing.  In some
cases, this in turn has caused current versions of the API code to become unwieldy to developers.  For example, the 3D graphics world has grown exponentially in the last decade, while the procedures for 2D applications have largely stayed the same.
Initially, there was only an API that helped developers render 2D images, and while at its inception, the API was a revolutionary innovation freeing developers to create games and other 2D graphics applications, the algorithms for the creation,
processing and rendering of pixels and polygons in 2D space have been largely static in recent years.  On the other hand, the algorithms for the creation, processing and rendering of 3D objects on a 2D display space have grown considerably.  While the
creation, processing and rendering of 3D objects by a 3D API utilizes algorithms and function calls of the 2D API, a single set of APIs does not exist for the purpose of creating both 2D and 3D objects.  There are thus typically multiple choices for a
developer to make, when creating, processing or rendering an object, because there are multiple roads to the same result depending upon which API function calls are utilized to achieve the result.
For yet another example, there are three ways for a developer to perform a texture download depending upon the hardware involved, wherein data is transferred from the system memory surface to the display memory surface.  It would be desirable to
provide a single fast texture download.  There are thus situations where the number of mappings from an application to various API objects is diverse, whereby multiple commands perform the same or similar actions.  In essence, there is an overlapping of
functionality among API objects that is not exploited.  It would thus be desirable to centralize this diversity and provide a unified singular command structure, thereby reducing the number of diverse, and potentially redundant, mappings to API objects.
In addition, there are a number of instances in which existing 3D graphics APIs inconvenience the developer by requiring the developer to write substantially more complex code than is necessary in view of today&#39;s computing environments.  For
example, currently it requires at least five programming steps to effect a resolution change, inconveniencing the developer each time a resolution change is desired.  While coding five steps is still better than interfacing directly with graphics system
components, it would still be desirable to provide a single command to effect a resolution change.  Thus, there are a variety of instances in which it would be desirable to unify existing API command structures into concrete, atomic algorithmic elements
that ease the task of development.
Since graphics peripherals and other specialized graphics hardware and integrated circuits (ICs) are generally designed for specific tasks, they are much better than the host processor at performing certain types of functions.  For example, a
video card may have special purpose hardware that can copy or process pixels much faster than the CPU.  A high level interface using a multi-purpose processor may not take advantage of the specialized functionality and may also include additional lines
of code that in the long run can consume valuable computer resources, especially when repeated over and over as can be the case with graphics applications.  Thus, one of the problems with current 3D graphics architectures is an over-reliance on general
host computing resources.  This over-reliance on general processing has led to major advances in specialized graphics chips designed primarily for the purpose of improving the performance of graphics applications.
Other failings in today&#39;s graphical software interfaces are due to advances in hardware technology that have enabled the ability to move functionality previously implemented in software into specialized hardware.  An example of this is the way in
which graphics rendering and processing functionality has been merged or pushed into specialized graphics hardware that can operate, on average, at orders of magnitude faster than previous generations.  In the last two years, graphics hardware has been
matching or beating the expectations of Moore&#39;s law, creating a whole new universe of high performance devices and 3D graphics chips that can perform specialized tasks at previously unheard of rates and efficiency.  This in turn has left pre-existing
software interfaces lagging behind the functionality of the hardware devices and the graphics community, and in certain cases, the software interfaces are currently limiting this increased hardware functionality.  This can be the case, for example, when
the execution of the commands of the software interface becomes the rate determining step of a graphics operation that could otherwise be performed more efficiently with hardware.  Thus, in addition to the problems identified above, it would be desirable
to address with software solutions the increased functionality of today&#39;s graphics hardware at various points between developers, the 3D graphics API and the new hardware.
For example, in the past, when a developer switched graphics data from one memory location to another, the developer had to deal with switching the data i.e., by destroying and recreating the data.  In this regard, there are two types of
`containers` that today&#39;s graphics APIs present to a developer for use: one for pixels and one for polygons.  Essentially, by passing arguments to the graphics API (placing data into the containers), the developers can manipulate and render various
chunks of data.  Once these containers are filled with data, there are various places, such as system memory or on a 3D card or chip, where this data may be stored for further manipulation.  The filling and placement of the containers is achieved via
various components or function calls of the graphics API.  The decision as to where to place this data is generally a performance issue.  Data for which fast access is not necessary can be stored in system memory, whereas data for which speed of access
is more important may be stored on a graphics chip designed for ultra fast access.
As mentioned, it is sometimes desirable for a developer to switch data or chunks of data from one memory location to another memory location at different stages of processing.  In the past, when a developer desired to switch data from one memory
location to another, the developer had to deal with switching the data i.e., destroying the data in the old location and recreating the data in the new location.  Previously, this may not have caused a performance decrease because, relative to today, the
bandwidth for high performance processing on a graphics board or chip was low.  This may have actually given the developer more flexibility to place data in an environment in which it would be processed most efficiently.  With limited options, this task
was not overly burdensome even though the developer had to custom code the switching of data for each application.
Given the complexity and high performance rewards of using today&#39;s hardware, which may have their own memory on board or on chip, it would be advantageous to be able to automatically transition data objects between memory types to enable the
seamless switching of data.  It would in theory be desirable to keep all data on the faster hardware chip memory to process data.  However, in reality, there is little room for such on chip graphics data, sometimes as few as a hundred (high speed)
registers.  Thus, typically a cache managing algorithm optimizes the tradeoff between host system memory and video memory on the 3D card or chip so as to keep a maximum amount of data for processing in graphics hardware memory without causing overflow.
Previously, a developer would have to write such a cache managing algorithm for every application and the cache managing algorithm would have to be individually tailored to the programming task at hand.  Thus, it would be desirable to enable the software
interface to hide the optimal cache managing algorithm from the developer so that the developer need not be concerned with the optimal tradeoff of system resources, and so that efficient switching of data can take place behind the scenes, thereby
simplifying the developer&#39;s task.
Another area in which such a software solution is desirable in view of today&#39;s graphics devices lies in the transmission of graphics data to specialized graphics ICs and other specialized devices.  For example, as mentioned, there are two types
of data containers, pixel and polygon, that a developer may fill with data objects for further operation and processing.  These containers correspond to data structures or formats that graphics modules, ICs and devices have come to expect for the
processing and storage of graphics data, such as pixels and polygons.  Currently, when a developer goes about specifying multiple data objects to fill multiple containers, these data objects are fed to a 3D chip one by one, or in a serial fashion.  Thus,
currently, developers are not able to feed graphics data objects in parallel to a 3D chip for processing and yet today&#39;s 3D graphics chips have evolved to function upon and/or store multiple data objects simultaneously.
Another area in the graphics world that has rapidly evolved is in the area of procedural shading.  Vertex and pixel shaders, which may be implemented with software or hardware or with a combination of both, have specialized functionality that
enables the processing of pixels or vertices, so as to perform lighting operations, and other transformations upon graphics data.  Vertex and pixel shaders are two types of procedural shaders that are currently implemented in specialized graphics ICs.
With current 3D APIs, the API does not provide packaged operations to be performed in connection with procedural shaders, such as vertex and pixel shaders.  Invariably, a developer designs these procedural shader algorithms from scratch for each
application.  While there may be some crossover from application to application, the bottom line is that a developer has to implement these algorithms each time for a new application.  Thus, while the core commands for use with the procedural shaders are
available to the developer, the effective or efficient combination of those commands is left to the developer.  Consequently, algorithms that are unique, common and useful in connection with typical 3D graphics processes, such as algorithms that are
typically used in connection with procedural shaders, are designed from the ground up for each application.  Conceptually, these elements for acting on procedural shaders have been customized by necessity and thus provided `above` the API.  With present
procedural shader hardware designs, for example, a specialized set of assembly language instructions has been developed, which in part replaces or duplicates some of the custom coding currently implemented by the developer.  However, there is no
mechanism that exposes to the developer unique algorithmic elements for use with procedural shaders via a mechanism that is conceptually below or inside the software interface.
As is apparent from the above, advances in hardware and graphics algorithms have been revolutionizing the way graphics platforms operate.  Generally speaking, however, current 3D graphics chips on the market are rigid in design and have very
little flexibility in terms of their operation diversity.  For example, while they provide high performance for certain operations, current chips do not necessarily have the flexibility to alter their operation via software.  While EEPROM technology and
the like has existed for sometime where the operation of a chip can be programmably reset, the logic of graphics chips has been typically preset at the factory.  However, there are innumerable circumstances where it is desirable to take operations
previously customized by a developer for an application, and make these operations downloadable to a 3D chip for improved performance characteristics.  As cutting edge 3D graphics chips, still being designed in some cases, have begun to handle such
programmable functionality, by including flexible on chip processing and limited on chip memory, to remove custom graphics code from the processing of the host processor and to place such programmable and downloadable functionality in a graphics chip
would be of key importance in future graphics platforms.  Thus, there is a need for an API that provides this ability to have a programmable 3D chip, wherein programming or algorithmic elements written by the developer can be downloaded to the chip,
thereby programming the chip to perform those algorithms at improved performance levels.  Related to this case where a developer may write a routine downloadable to the 3D chip, there are also a set of algorithmic elements that are provided in connection
with the 3D API (routines that are not written by the developer, but which have already been programmed for the developer).  Similarly, it would be desirable to be able to download these API algorithms to a programmable 3D chip for improved performance.
It would thus be advantageous to have the ability to download 3D algorithmic elements to provide improved performance, greater control as well as development ease.
While 3D graphics chips are currently undergoing improvements, there are also improvements taking place on the display side of the API i.e., once data has been processed, the API facilitates the transfer of graphics data to the rasterizer.  The
rasterizer is a specialized display processor chip that, among other things, converts digital pixel data into an analog form appropriate for a display device, such as a monitor.  While direct video memory access was previously a possibility, it is no
longer a possibility, due to faster techniques employing specialized hardware.  Currently, specialized or private drivers and surface formats are used in connection with very fast graphics accelerators.  With direct rasterizer/processor access to display
memory surfaces, &quot;chunks&quot; of surfaces can be moved around according to the specialized surface format, and pulled for processing as efficiency dictates.  Thus, the pipeline between display memory surface space and the display itself has been made more
efficient, but there currently is no mechanism that makes these direct rasterizer/processor memory access techniques seamless to the application developers via a graphics API whose applications ultimately benefit from the efficiencies of display surface
data chunk manipulation.
Thus, as a consequence, the graphics APIs used as the layer that insulates game developers from the details of these changes also need to be changed to be in line with the changes in hardware.  When implemented efficiently, these changes can
create noticeable differences in the ease and robustness with which APIs may be used by game or other graphics developers.  Additionally, the advances in hardware create an opportunity to simplify some processes by increasing maintainability, decreasing
memory consumption and providing greater usability of the 3D rendering and processing pipeline.
It would be advantageous to provide an optimization that allows a developer coding an application to specify the transmission of multiple data objects, wherever originated or located at the time of operation, to a 3D chip simultaneously or in
parallel.  Because graphics ICs have evolved to possess functionality wherein data objects can be processed in parallel, it would be desirable to expose this functionality to developers, thereby allowing developers to specify multiple data objects upon
which operations are to be performed simultaneously.
In view of the above problems, it would be beneficial to prevent the severance of connections between surfaces and objects when multiple applications maintain connections to surface memory space.  It would be desirable to unify existing API
command structures into concrete, atomic algorithmic elements to enable greater development ease.  It would be advantageous to be able to automatically transition data objects between memory types to enable the seamless switching of data.  It would be
further beneficial to be able to feed graphics data objects in parallel to a 3D chip for processing.  It would be further advantageous to have the ability to download 3D algorithmic elements to a 3D graphics chip.  It would be still further beneficial to
make today&#39;s direct rasterizer/processor memory access techniques seamless to the application developers via a graphics API.  It would be yet further advantageous to leverage the algorithmic components used for procedural shader operations provided by
today&#39;s procedural shaders by exposing the components to the developer via the software interface.
In view of the foregoing, the present invention provides a method and system for controlling the algorithmic elements in 3D graphics systems via an improved 3D graphics API.  More particularly, the present invention is directed to an API that
enables programmability of a 3D chip, wherein programming or algorithmic elements written by a developer can be downloaded to the chip, thereby programming the chip to perform those algorithms.
According to aspects of the invention, 3D algorithmic elements written by a developer can be downloaded to the 3D chip for improved performance characteristics.  A developer writes a routine that may be downloaded to the 3D graphics chip.  There
are also a set of algorithmic elements that are provided in connection with the API of the present invention (routines that do not have to be written by developer, but which have already been programmed for the developer), that are downloadable to the
programmable chip for improved performance.  A developer may download preexisting API objects to the 3D graphics chip.
In an exemplary embodiment of the present invention, a developer adheres to a specific format for packing up an algorithmic element, or set of instructions, for implementation by a 3D graphics chip.  The developer packs the instruction set into
an array of numbers, by referring to a list of `tokens` understood by the 3D graphics chip.  This array of numbers in turn is mapped correctly to the 3D graphics chip for implementation of the algorithmic element by the 3D graphics chip.
According to another embodiment of the present invention, a specialized set of instructions, or list of tokens packed as an array of numbers, can be combined in such ways as to create useful algorithmic elements.  The present invention takes
these useful combinations and exposes the algorithmic elements to the developer by way of the API.  Conceptually, therefore, the present invention provides these useful algorithmic elements for acting on procedural shaders below or inside the API.  The
present invention provides API objects, which are useful combinations of a procedural shader&#39;s instruction set for acting upon the shader.  In this fashion, algorithmic elements for use with a procedural shader are exposed to the developer.
The present invention provides a new and improved API as a layer between application developers and the current state of the art of graphics hardware and the pipeline that renders and processes the graphics data.  An API is provided that enables
programmability of a 3D chip, wherein programming or algorithmic elements written by the developer can be downloaded to the chip, thereby programming the chip to perform those algorithms.  A developer writes a routine that is downloadable to a 3D
graphics chip.  There are also a set of algorithmic elements that are provided in connection with the API that have already been programmed for the developer, that are downloadable to the programmable chip for improved performance.  Thus, a developer may
download preexisting API objects to a 3D graphics chip.  A developer adheres to a specific format for packing up an algorithmic element, or set of instructions, for implementation by a 3D graphics chip.  The developer packs the instruction set into an
array of numbers, by referring to a list of `tokens` understood by the 3D graphics chip.  This array of numbers in turn is mapped correctly to the 3D graphics chip for implementation of the algorithmic element by the 3D graphics chip.
of computer-executable instructions, such as program modules, being executed by one or more computers, such as client workstations, servers or other devices.  Generally, program modules include routines, programs, objects, components, data structures and
(PCs), server computers, hand-held or laptop devices, multi-processor systems, microprocessor-based systems, programmable consumer electronics, network PCs, minicomputers, mainframe computers, gaming platforms and the like.  The invention may also be
any limitation as to the scope of use or functionality of the invention.  For example, graphics application programming interfaces may be useful in a wide range of platforms.  Neither should the computing environment 100 be interpreted as having any
dependency or requirement relating to any one or combination of components illustrated in the exemplary operating environment 100.
As mentioned, a computer, such as described above, can be deployed as part of a computer network.  Further, the present invention pertains to any computer system having any number of memory or storage units, and any number of applications and
processes occurring across any number of storage units or volumes.  Thus, the present invention may apply to both server computers and client computers deployed in a network environment, having remote or local storage.  More and more, graphics
applications are becoming deployed in network environments.  FIG. 2 thus illustrates an exemplary network environment, with a server in communication with client computers via a network, in which the present invention may be employed.  As shown, a number
of servers 10a, 10b, etc., are interconnected via a communications network 14 (which may be a LAN, WAN, intranet or the Internet) with a number of client computers 110a, 110b, 110c, etc. In a network environment in which the communications network 14 is
the Internet, for example, servers 10 can be Web servers with which the clients 110a, 110b, etc. communicate via any of a number of known protocols such as hypertext transfer protocol (HTTP).  The invention may also leverage peer to peer networking
techniques.  Each client computer 110 and server computer 10 may be equipped with various application program modules 135, other program modules 136 and program data 137, and with connections or access to various types of storage elements or objects,
across which files may be stored or to which portion(s) of files may be downloaded or migrated.  Each client computer 110 and server computer 10 may also be connected to additional storage elements 20, such as a database.  Thus, the present invention can
be utilized in a computer network environment having client computers for accessing and interacting with a network and server computers 10a, 10b, etc. for interacting with client computers.
As mentioned in the background, a resource contention issue sometimes occurs due to the demands of multiple devices and applications requiring graphics system resources simultaneously.  Current 3D graphics APIs sometimes improperly manage
resources such that if multiple applications running simultaneously are maintaining connections to multiple surfaces from various objects of the graphics system, sometimes these connections to surfaces can become severed or disconnected.  If the
connection to surface memory for any one application is severed, a user may have to restart the application or begin certain portions of the application again in order to recreate a proper connection.
FIG. 3A illustrates some elementary components of a 3D graphics system.  A rasterizer 310 processes graphics data from surface memory 320 in preparation for its transmission to a display device having display memory 300.  Any number of objects
330a, 330b to 330n may be created through graphics API 340 when applications 350a and 350b or more are running.  Objects 330a, 330b to 330n may be part of the graphics API 340 or may be provided separately for use with the graphics system.  As FIG. 3A
illustrates, a connection between surface space 320 and, for example, object 330b may become severed due to improper maintenance of system resources when performing thousands of high speed operations for multiple applications.  For example, some objects
are responsible for building and moving frames to surface space.  Over the course of operation of a graphics application, thousands and thousands of such build and move operations may take place.  Presently, there is only one point in the API code that
performs a `check` to see if the connection is properly maintained to achieve such operations.  Previously, during the course of building, processing and presenting frame data, multiple checks were performed, essentially each time any operation occurred
with respect to the data.  This, however, is wasteful of computing resources in the event that a connection is lost since each check consumes computing resources on its own.
In accordance with the present invention, by performing a check and monitoring connections and system resources each time a frame is presented, the consumption of valuable resources between present operations according to various operations is
avoided.  As shown in FIG. 3B, the connection between surface 320b and object 330b is treated as if it persists between present operations in accordance with the present invention, even where the connection has been lost.  For example, where a typical
check for the persistence of the connection between surfaces and objects includes returning a flag, such as true or false, depending upon the whether the connection persists, these operations may be skipped or spoofed such that between present
operations, the flag continues to indicate that the connection persists, even if it has been lost, thus avoiding multiple, redundant checks for the persistence of the connection.  As a result, operations are streamlined between present calls such that
checks are made when expedient to do so.  Thus, the present invention prevents wasteful consumption of computing resources due to the loss of connection between surfaces and objects when multiple devices and applications demand premium system resources
In an exemplary embodiment, the present invention provides a solution by unifying the command structure that previously checked for lost connections to surfaces.  Previously, there were innumerable places where the application checked for and
handled resource issues between present calls.  This distributed the checkpoints and created multiple, if not hundreds or thousands of places throughout the application where checks occurred between present calls, creating inefficiencies and further
opportunities for error due to wasteful devotion of computing resources.  In accordance with the present invention, each time data is `presented` to the surface memory space 320 according to a `present` function call, the 3D API of the invention checks
for these resource contention issues.  Thus, instead of having many different cases occurring at different times for which the API might determine that a connection has been lost, the 3D API of the invention checks each time a `present` function call is
made, thereby providing a single case for a lost connection such that resources may be newly allocated according to the same unified procedure.  This check may be performed before or after the present call, or included therein.  It can be appreciated
that any call, such as a present function call, that is cyclical and occurs once per frame e.g., at a typical 30 or 60 frames per second, or other recurring event may also be utilized to achieve the above goals.
The subsequent versioning of a software product to meet the needs of an evolving operating environment sometimes results in inefficiencies wherein once separate or merely related modules may be more efficiently placed together, rewritten or
merged.  Thus, the present invention unifies existing API command structures into concrete, atomic algorithmic elements that ease the task of development.
For example, while the creation, processing and rendering of 3D objects by a 3D API utilizes algorithms and function calls of the 2D API, a single set of APIs does not exist for the purpose of creating both 2D and 3D objects.  There are thus
typically multiple choices for a developer to make, when creating, processing or rendering an object, which makes the developer&#39;s work more complex.  For example, with reference to FIG. 4A, there are numerous instances where the current 2D graphics API
shares functionality with the current 3D graphics API, because, for example, both include the same function calls.  There are also instances wherein to perform a function 410a with the 3D graphics API 410 may involve a function call to function 400a of
the 2D graphics API, and vice versa.  While the overlap in the figure is illustrated simply with dashed lines, the reality of current interoperation is far from simple, and leaves the developer with too many choices.  The present invention thus provides
a single 2D and 3D graphics API, providing a unified programming body with which developers may work.
Currently, there are no 3D graphics APIs that unify 2D and 3D graphics data types.  Historically, due to the evolution of 2D and 3D graphics processing, with `modern` 2D graphics applications beginning as early as the 1970s and with 3D graphics
applications developing in parallel fashion at a later time, 2D and 3D data types have simply been treated differently by different applications i.e., memory allocation, memory structures and memory management have been different as between 2D and 3D
data types.  Thus, because the present invention unifies data types and choices with respect to 2D and 3D data types, memory management techniques have been unified in accordance with the present invention, eliminating ad hoc memory management based on
whether the data was a 2D data type or a 3D data type.  Due to the unification of 2D and 3D data formatting, the definition of data is simplified from the perspective of the developer.  Thus, a long felt need in the art for a unified 2D and 3D API is
In the above scenario, there is an overlapping of functionality among API objects that is not exploited.  There are also other instances in which the number of choices available to developers for the same or similar functionality can both
complicate the development process and create a source of inefficiency.  For instance, there are three ways for a developer to perform a texture download depending upon the hardware involved, wherein data is transferred from a system memory surface to a
3D display memory surface.  Textures are rectangular arrays of colored pixels, which tend to be square in graphics applications, and when processed in quantity, represent a lot of data.  A texture download, in this regard, is important because ultimately
slow texture downloading can become a bottleneck in graphics data processing.  Different texture downloads, depending upon the hardware used incident thereto, have different data transfer rates associated therewith and thus the choice of texture download
made by the developer can affect the overall system performance.  The optimization of this data transfer rate, if required of the developer, can involve considerable time, effort and skill.
As illustrated in FIG. 4B, three different functions or ways 340a, 340b and 340c of graphics API 340 are currently available to a developer for use in connection with a texture download depending upon which hardware 430a, 430b .  . . 430n is
involved.  When multiple hardware 430a, 430b .  . . 430n is present, and a developer has three choices to make regarding texture downloading data from a system memory surface 440a, 440b .  . . 440n to 3D display memory surface 450, the decision is
undesirably time-consuming, complex and requires an understanding of the underlying hardware in order to make efficient decisions.  The present invention thus provides a single fast texture download.  Instead of having a plurality of mappings from an
application to API objects, and multiple commands that perform the same or similar actions, the present invention provides a single mapping.  The present invention thus centralizes the diversity of current texture downloads and provides a unified
singular command structure, thereby reducing the number of diverse, and redundant, mappings to API texture downloads.  Instead of choosing among API objects 340a, 340b or 340c of FIG. 4B, or a combination thereof, or having to write an optimization
routine that optimizes the use of 340a, 340b or 340c, the present invention provides a single texture download object 340_td for use by the developer, as shown in FIG. 4C.
Optimization of graphics components used incident to a texture download, such as hardware 430a, 430b, .  . . 430n, is thus performed by the API object 340_td in accordance with the present invention, thereby freeing the developer to be concerned
with other aspects of the graphics application.  For example, according to one optimization, the number of times used and order of hardware components 430a, 430b, etc. utilized in connection with a texture download is hidden from the developer.  For
example, in one embodiment, object 340_td keeps track of how well the hardware objects 430a, 430b, etc. are keeping up in terms of free memory (capacity) and speed of data processing and transfer.  This may be configured staticly beforehand, so as to
control the number and order of hardware components 430a, 430b, etc. that may be used and in connection with a texture download, or this may be performed dynamically based upon an evaluation of the performance of texture downloading, with feedback from
the hardware components 430a, 430b, etc.
components, the present invention unifies the command structure of a resolution change, allowing a developer to effect a resolution change with a single API command.  The present invention thus provides a single command to effect a resolution change,
insulating the developer from the detailed changes that are made in the graphics system in order to effect the change.  This is yet another example where current graphics APIs require the developer to have an overly detailed understanding of the
underlying graphics hardware.  As shown in FIG. 4D, there are currently five steps or commands 340_rc1, 340_rc2, 340_rc3, 340_rc4 and 340_rc5 that a developer D1 must enter in order to effect a graphics system resolution change RC.  Each of commands
340_rc1, 340_rc2, 340_rc3, 340_rc4 and 340_rc5 has an independent bearing on the graphics system which can involve overlapping functionality or redundant arguments.  Thus, as FIG. 4E illustrates, the present invention provides a single efficient API
object 340_rc to achieve a resolution change.  Thus, in these and other instances, the present invention unifies existing API command structures into concrete, atomic algorithmic elements that ease the task of development for a developer.
Thus far, the functionality of 3D hardware chips or components has been relatively fixed from the vantage point of the developer, leaving little flexibility at the developer end to perform efficient sets of operations that are tailored to an
application or that allow the developer to control the algorithmic elements that are performed by the 3D graphics chip.  There are innumerable circumstances where the state of the art of graphics hardware has made it desirable to take operations
previously customized by a developer for an application, and make these operations downloadable to a 3D chip for improved performance characteristics.  Since 3D graphics chips have evolved to be very high performance compared to host system processing
space, it would be advantageous to allow a developer to download functionality to the 3D chip.
Thus, by way of the API of the present invention, 3D algorithmic elements written by a developer can be downloaded to the 3D chip for improved performance characteristics.  FIG. 5 illustrates this process whereby a developer D1 writes a routine
500 that may be downloaded to 3D graphics chip 510.  Similar to this case where a developer may write a routine 500 downloadable to the 3D chip 510, there are also a set of algorithmic elements that are provided in connection with the API of the present
invention (routines that do not have to be written by developer D1, but which have already been programmed for the developer D1), that are downloadable to the programmable chip 510 for improved performance.  As shown in FIG. 5, a developer D1 may
download preexisting API objects 340a, 340b, .  . . 340n to 3D graphics chip 510.  While graphics applications generally involve a performance specification that includes fast processing and fast rendering, the ability to control 3D algorithmic elements
in this fashion is very advantageous, because it allows a developer access to the fastest, highest performance portions of the graphics processing system, enabling the developer to download efficient algorithmic elements to the graphics chip 510 that are
tailored to the application at hand.
In an exemplary embodiment, a developer adheres to a specific format for packing up an algorithmic element, or set of instructions, for implementation by a 3D graphics chip.  The developer packs the instruction set into an array of numbers, by
referring to a list of `tokens` understood by the 3D graphics chip.  This array of numbers in turn is mapped correctly to the 3D graphics chip for implementation of the algorithmic element by the 3D graphics chip.  Further background, hereby incorporated
by reference in its entirety, may be found in U.S.  patent application Ser.  No. 09/801,079 entitled &quot;API Communications For Vertex And Pixel Shaders&quot; having inventors Boyd and Toelle, now U.S.  Pat.  No. 6,819,325.
With respect to unique algorithmic elements for use with procedural shaders in accordance with the present invention, some general background is instructive: rendering and displaying three dimensional graphics typically involves many calculations
and computations.  For example, to render a three dimensional object, a set of coordinate points or vertices that define the object to be rendered must be formed.  Vertices can be joined to form polygons that define the surface of the object to be
rendered and displayed.  Once the vertices that define an object are formed, the vertices are transformed from an object or model frame of reference to a world frame of reference and finally to two dimensional coordinates that can be displayed on a flat
display device.  Along the way, vertices may be rotated, scaled, eliminated or clipped because they fall outside the viewable area, are lit by various lighting schemes, colorized, and so forth.  Thus, the process of rendering and displaying a three
dimensional object can be computationally intensive and may involve a large number of vertices.
A triangle has many helpful properties that make it ideal for use in rendering three dimensional surfaces.  A triangle is completely defined by three vertices and a triangle also uniquely defines a plane.  Thus, many systems will use a plurality
of triangles to render a three dimensional surface.  If each triangle is passed separately to the graphic subsystem that renders the three dimensional object, then three vertices for each triangle must be passed and processed by the graphic subsystem.
However, the number of vertices that must be passed and processed by the graphic subsystem can be reduced through &quot;vertex sharing.&quot; Vertex sharing relies on a property of shared sides among triangles.  Although it takes three vertices to define one
triangle, it only takes four vertices to define two triangles if they share a common side.  In order to take advantage of vertex sharing to reduce the number of vertices needed to render an object, pipelined systems have been developed that divide a
three dimensional object into triangle strips that can then be processed and displayed efficiently.
Indeed, specialized 3D software objects and/or hardware components such as procedural shaders have been created or designed for the purpose of carrying out specialized graphics functionality upon graphics data, in order to speed the process of
rendering complex graphics objects.  Procedural shaders, such as vertex and pixel shaders, have traditionally been used to perform such complex transformations on pixels and/or arrays of pixels or triangles.
However, the functionality of these procedural shading software objects or hardware components has been relatively fixed, leaving little flexibility at the developer end to perform efficient sets of operations that may be efficiently tailored to
a particular graphics application or task.
Thus, with previous 3D APIs, the API did not provide the developer with flexibility as to operations that could be performed in connection with procedural shaders, such as vertex and pixel shaders.  Vertex and pixel shaders, which may be
implemented with software or in hardware or with a combination of both, have specialized functionality.  Currently, in order to utilize useful algorithmic elements of a procedural shader, or otherwise use fixed and limited functionality of the procedural
shader, a developer has to invariably design software procedural shader algorithms from scratch for each application.  While the core commands for use with the procedural shaders were available to the developer, the effective or efficient combination of
these commands is left to the developer.  Consequently, algorithms that are unique, common and useful in connection with typical 3D graphics processes, such as for typical use in connection with procedural shaders, are developed from the ground up for
each application.  Conceptually, these elements for acting on procedural shaders have been customized by necessity for each application and thus provided `above` the API, programmed as part of the graphics application itself.  As shown in FIG. 6A,
developer D1, with access to a specification for a procedural shader 610, programs an inflexible object 600 so as to work with or control the procedural shader 610.  As FIG. 6A illustrates, developer D1 develops a shading algorithm with code.  After
customization by the developer D1, object 600 interacts with shader(s) 610 via graphics API 340.
With present hardware designs of procedural shaders, however, a specialized set of assembly language instructions has been developed creating flexibility of procedural shader use.  The developer still has access to the specialized set of
instructions as in the past.  Advantageously, with the present invention, this specialized set of instructions, or list of tokens packed as an array of numbers, can be combined in such ways as to create useful algorithmic elements.  The present invention
takes these useful combinations and exposes the algorithmic elements to the developer by way of the API 340.  Conceptually, therefore, the present invention provides these useful algorithmic elements for acting on procedural shaders below or inside the
API.  As FIG. 6B illustrates, the present invention provides API objects 340_ps1, 340_ps2, .  . . 340_psn, which are useful combinations of procedural shader 610&#39;s instruction set for acting upon shader 610.  In this fashion, algorithmic elements for use
with procedural shader 610 are exposed to the developer D1.
For more concrete examples of algorithmic elements that used to be customized by necessity above the API, which are now provided for use below are any of the following types of techniques, taken alone or in combination: lighting, colorizing,
mapping, texturizing, surfacing, shading, enhancing, and other image processing techniques.
Some exemplary code or definitional pseudocode for a procedural shader, such as a vertex shader, is provided below.  The declaration portion of an exemplary procedural shader defines the static external interface of the procedural shader.  The
information in the declaration includes assignments of vertex shader input registers to data streams.  These assignments bind a specific vertex register to a single component within a vertex stream.  A vertex stream element is identified by a byte offset
within the stream and a type.  The type specifies the arithmetic data type plus the dimensionality (1, 2, 3, or 4 values).  Stream data that is less than four values are preferably expanded out to four values with zero or more 0.F values and one 1.F
The information in the declaration also includes assignment of vertex shader input registers to implicit data from the primitive tessellator.  This controls the loading of vertex data which is not loaded from a stream, but rather is generated
during primitive tessellation prior to the vertex shader.
Moreover, the information in the declaration also includes loading data into the constant memory at the time a procedural shader is set as the current procedural shader.  Each token specifies values for one or more contiguous 4 DWORD constant
registers.  This allows the procedural shader to update an arbitrary subset of the constant memory, overwriting the device state (which contains the current values of the constant memory).  Note that these values can be subsequently overwritten (between
DrawPrimitive calls) during the time a procedural shader is bound to a device via the SetVertexShaderConstant method.
Declaration arrays are single-dimensional arrays of DWORDs composed of multiple tokens each of which is one or more DWORDs.  The single DWORD token value 0xFFFFFFFF is a special token used to indicate the end of the declaration array.  The single
DWORD token value 0x00000000 is a NOP token with is ignored during the declaration parsing.  Note that 0x00000000 is a valid value for DWORDs following the first DWORD for multiple word tokens.
[31:29] TokenType 0x0--NOP (requires all DWORD bits to be zero) 0x1--stream selector 0x2--stream data definition (map to vertex input memory) 0x3--vertex input memory from tessellator 0x4--constant memory from shader 0x5--extension 0x6--reserved
NOP Token (single DWORD token) [31:29] 0x0 [28:00] 0x0
Stream Selector (single DWORD token) [31:29] 0x1 [28] indicates whether this is a tessellator stream [27:04] 0x0 [03:00] stream selector (0.  . . 15)
Stream Data Definition (single DWORD token) Vertex Input Register Load [31:29] 0x2 [28] 0x0 [27:20] 0x0 [19:16] type (dimensionality and data type) [15:04] 0x0 [03:00] vertex register address (0 .  . . 15)
Data Skip (no register load) [31:29] 0x2 [28] 0x1 [27:20] 0x0 [19:16] count of DWORDS to skip over (0 .  . . 15) [15:00] 0x0
Vertex Input Memory from Tessellator Data (single DWORD token) [31:29] 0x3 [28] indicates whether data is normals or u/v [27:24] 0x0 [23:20] vertex register address (0 .  . . 15) [19:16] type (dimensionality) [15:04] 0x0 [03:00] vertex register
address (0 .  . . 15)
Constant Memory from Shader (multiple DWORD token) [31:29] 0x4 [28:25] count of 4*DWORD constants to load (0 .  . . 15) [24:07] 0x0 [06:00] constant memory address (0.  . . 95)
Extension Token (single or multiple DWORD token) [31:29] 0x5 [28:24] count of additional DWORDs in token (0 .  . . 31) [23:00] extension-specific information
End-of-array token (single DWORD token) [31:29] 0x7 [28:00] 0x1fffffff
The stream selector token is desirably followed by a contiguous set of stream data definition tokens.  This token sequence fully defines that stream, including the set of elements within the stream, the order in which the elements appear, the
type of each element, and the vertex register into which to load an element.
Streams are allowed to include data which is not loaded into a vertex register, thus allowing data which is not used for this shader to exist in the vertex stream.  This skipped data is defined only by a count of DWORDs to skip over, since the
type information is irrelevant.
Stream Select: stream=0 Stream Data Definition (Load): type=FLOAT3; register=3 Stream Data Definition (Load): type=FLOAT3; register=4 Stream Data Definition (Skip): count=2 Stream Data Definition (Load): type=FLOAT2; register=7 defines stream
zero to consist of four elements, three of which are loaded into registers and the fourth skipped over.  Register 3 is loaded with the first three DWORDs in each vertex interpreted as FLOAT data.  Register 4 is loaded with the fourth, fifth, and sixth
DWORDs interpreted as FLOAT data.  The next two DWORDs (seventh and eighth) are skipped over and not loaded into any vertex input register.  Register 7 is loaded with the ninth and tenth DWORDS interpreted as FLOAT data.
While the above exemplary computer-executable instructions have been described in the context of a procedural shader, these concepts and principles may be applied to any 3D hardware rendering device utilized in connection with a graphics display
As mentioned above, while direct video memory access was once a possibility, it is no longer a possibility according to today&#39;s currently utilized graphics architectures.  In accordance with today&#39;s graphics pipeline architecture, specialized or
private drivers and surface formats are used in connection with very fast graphics accelerators.  With direct rasterizer/processor access to display memory surfaces, &quot;chunks&quot; of surfaces can be moved around according to the specialized surface format,
and pulled for processing as efficiency dictates.  Thus, the pipeline between display memory surface space and the display itself has been made more efficient.  With reference to FIG. 7A, an example of the type of modern `chunk` manipulation is
illustrated at a microcosmic level i.e., only 4 squares or chunks of data are illustrated.  Private driver 700 causes chunks 710a_1 through 710a_4 to be grabbed as efficiency dictates and are subsequently manipulated with a rasterizer into an
intermediate form 710b, wherein the original image may be unrecognizable.  Then, data is moved along the graphics pipeline to render the final image on display 710c, whereby band B_1 of data may translate to band B_2 in the displayed image.  These
mathematical transformations, and timing thereof, have advanced algorithms for determining the efficiency of chunk grabbing and placement.  In essence, many images involve redundant data, or data that can be exploited based upon temporal and spatial
knowledge, and these algorithms exploit such knowledge to create an extremely efficient and fast graphics data rendering pipeline.
Without the API of the present invention, however, display memory surface space must be set up properly by the developer to work with this privatized format.  FIG. 7B illustrates API 340 in accordance with the present invention.  The API object
340_1 of the present invention hides the efficiencies gained from the privatized driver format and rasterizer operation as described above from applications and developers.  As far as the developer D1 writing application 350a is concerned, the display
memory surface 710a receives a rectangular image that is then rendered upon the display 710c, when in fact many efficient operations and data manipulations take place behind the scenes.  The present invention thus implements API object 340_1 such that it
exposes more of these efficient pipeline operations to the developer D1 so that developer D1 need be less concerned with the performance of hidden operations, such as locking and unlocking the privatized formats pursuant to various commands and function
calls over which the developer has no control.
Currently, when data is stored in hardware memory, the data is implemented in the privatized format illustrated in FIG. 7A.  When graphics data is stored in main memory, it is stored in the public, more easily understood format.  The privatized
driver performs this transition.  However, previously when graphics data stored in the hardware memory was asked for pursuant to some command or function call, the data was shuffled back to the public format, and then transmitted according to the private
format for hardware purposes.  Thus, upon an `unlock` command, the data was copied to system memory in the public format, and then the data was transformed to the privatized format where necessary.  Unfortunately, a problem arises wherein the same data
may be `unlocked` from hardware memory according to multiple function calls or commands, and consequently, multiple copies of the same data may be copied to the system memory.  The present invention addresses this problem by only allowing data to be
copied into system memory space when the developer specifically makes such a request, and thus ensuring that only copies that the developer knows about are resident in the system.  Reductions in performance as a result of multiple copies resident in main
memory, when unnecessary, are thus avoided.  In recognition that the data does not always need to be accessed from system memory space, the present invention thus allows the developer more freedom to command when data is copied to system memory when
stored in the privatized format associated with hardware memory.
As described in the background, there are generally two types of containers or data structures that the API presents to a developer for use: one for pixels and one for polygons.  Essentially, through passing arguments to the API (placing data
into the containers), the developers can manipulate various graphics data structures.  Once these containers are filled with data, there are various places, such as system memory or on a 3D card or chip, where this data may stored for further
manipulation.  The decision as to where to place this data is generally a performance issue.  For instance, data for which fast access is not necessary can be stored in system memory, whereas data for which speed of access is the most important may be
stored on a chip designed for ultra fast access.  It is also sometimes the case that it is desirable to switch data or chunks of data from one memory location to another memory location at different stages of processing.
As illustrated in FIG. 8A, in the past, when a developer switched data from one memory location to another, the developer had to code the switching the data i.e., by destroying the data in the old location and recreating the data in the new
location.  Developer D1, after creating a data container 850 or deleting and recreating a data container 850 via graphics API 340, has the decision to make regarding where to place the new data container 850.  While a developer may choose into which of
system memory 800, graphics chip memory 810 and other memory 820 data container 850 is placed, oftentimes, a developer D1 may write a custom cache managing algorithm for application 350a in an effort to efficiently manage resources.  In theory, the cache
managing algorithm would try to account for all of the system parameters and attempt to manage memory based upon data location, frequency of accessing or processing the data, and processing times associated with certain locations.  However, this is a
great inconvenience to developer D1 who has to custom build each cache managing algorithm for each new application 350a, and who through oversight may not manage resources as efficiently as possible.
As shown in FIG. 8B, in accordance with the present invention, the switching of data containers 850 from one location to another is performed automatically by an API object 340_cm.  Thus, polygon or pixel data objects 850 are automatically
transitioned between memory types such that the switching is seamless.  It appears as if the data chunks/containers 850 last forever to the developer, whereas in reality, the API hides the fact that the data is being transitioned to optimize system
performance.  For example, it would in theory be desirable to keep all data on the faster hardware chip memory to process data.  However, in reality, there is little room for such on chip data, sometimes as few as a hundred registers.  Thus, typically a
cache managing algorithm optimizes the tradeoff between host system memory and video memory on the 3D card so as to keep a maximum amount of data for processing in graphics hardware memory without causing overflow.  As alluded to above, currently, a
developer has to write such a cache managing algorithm for every application that is individually tailored to the programming task at hand.  The API 340 of the present invention hides an optimal cache managing algorithm from developer D1 so that
developer D1 need not be concerned with the optimal tradeoff of system resources, and so that efficient switching of data can take place `behind the scenes` simplifying the developer&#39;s task.  Data containers 850 are thus efficiently placed in storage to
maximize data processing rates, and storage space, whether a data container 850 is newly created, or switched from one location to another.
There are also current issues with respect to the transmission of data containers 850, either pixel and polygon, to a 3D chip.  Currently, when a developer goes about specifying multiple data objects to fill multiple containers, these data
objects are fed to the 3D chip one by one, or in a serial fashion.  As illustrated in FIG. 9A, currently, to feed two data containers 850a and 850b to graphics chip memory 810, developer D1 must feed the objects serially to memory 810.  In the figure,
t1&amp;lt;t2.  At t1, container 850a is retrieved from wherever stored or is created and at t2, it is fed to 3D graphics chip memory 810.  In a typical representation of a pixel with eight bits, x, y, z and w may be utilized for the spatial position of the
pixel and four more o1, o2, o3 and o4 may be utilized to represent the orientation of the surface, or color etc. at that position.  When the position and location of graphics data is constantly changing, serial transmission or loading of graphics chip
memory may not reduce performance significantly.  However, when there is redundancy of data e.g., when only the orientation of a pixel changes while the spatial position stays the same, opportunity to exploit the redundancy is lost.  Thus, serialized
data in container 850a is fed to 3D graphics chip memory 810 is fed to 3D graphics chip memory 810.  As will become evident, Even when performed very fast, the serial transmission of data containers 850a and 850b is not as fast as a parallel transmission
when there is some redundancy or other reason to transmit data in parallel.
Thus, an optimization in accordance with the present invention is that a developer coding an application may specify that multiple of these data objects wherever originated or located at the time of operation, may be fed to the 3D chip
simultaneously or in parallel.  As illustrated in FIG. 9B, both containers 850a and 850b may be fed to 3D graphics chip memory 810 at the same time.  At t1, the data containers 850a and 850b are retrieved or created, and at t2, containers 850a and 850b
are fed to 3D graphics chip memory in parallel.  While FIG. 9B illustrates the parallel transmission of two data containers to 3D graphics chip memory 810, any number of data containers up to the maximum storage of 3D graphics chip memory 810 may be fed
in parallel.  Thus, in the case of the above example where data is being transmitted to 3D graphics chip memory 810, wherein the data includes the same spatial position of pixel(s), but only the orientation or color is changing, the data may be loaded
into two separate containers 850a and 850b, with a header description understood by the graphics chip and implemented by graphics API 340, whereby a single copy of the position data can be loaded into container 850a, and the changing color or orientation
data may be loaded into container 850b.  Thus, when received by the graphics chip 810, the data is loaded correctly into register space and processed according to the header description.  In an exemplary implementation, up to 8 data objects 850a, 850b,
etc. may be fed in parallel to the graphics chip 810.  In such a configuration, the exploitation of redundancies may be performed in connection with any of the 8 values utilized to represent a pixel&#39;s location, orientation, etc. The present invention
thus supplements previous systems in which data could only be fed serially to a graphics chip with parallel feeding of graphics data.
The term graphics data as used herein is intended to cover not only video and/or audio data in any pre-processed, processed or compressed form, but is additionally intended to cover communications of data of any kind along the graphics pipeline
among the developer, the software interface of the present invention and various hardware and/or software components utilized incident to the graphics system.
embodiment for performing the same function of the present invention without deviating therefrom.  For example, while exemplary embodiments of the invention are described in the context of graphics data in a PC with a general operating system, one
skilled in the art will recognize that the present invention is not limited to the PC, and that a 3D graphics API may apply to any computing device, such as a gaming console, handheld computer, portable computer, etc., whether wired or wireless, and may
be applied to any number of such computing devices connected via a communications network, and interacting across the network.  Furthermore, it should be emphasized that a variety of computer platforms, including handheld device operating systems and
other application specific operating systems are contemplated, especially as the number of wireless networked devices continues to proliferate.  Therefore, the present invention should not be limited to any single embodiment, but rather construed in
Method and system for defining and controlling algorithmic elements in a graphics display system, Boyd, et al., Charles N. Boyd, Michael A. Toelle, Application number 10 934-274, Computer Graphics Processing And Selective Visual Display Systems, display system, Patent Search, Patent Agent, present invention provides, camera view, Patent application, patent data, anatomical structures, 3D chip, graphics chip
The present invention provides a new and improved software interface as a layer between application developers and the graphics pipeline that renders and processes the graphics data.BACKGROUND OF THE INVENTIONFor the vast majority of applications, application programmers rely on or utilize some form of software interface to interact with a computer and its associated devices. For graphics applications, developers or programmers typically utilize agraphics software interface, such as a 3D graphics application programming interface (API), to facilitate the interaction with constituent parts of a graphics system. Programmers typically rely on software interfaces to peripherals and devices so thatthey can focus on the specifics of their application rather than on the specifics of controlling a particular device and so that their efforts are not duplicated from application to application. However, even after generations of software interfaces,there are certain aspects of today's software interfaces that do not provide the level of performance desired and thus can be improved.There are several reasons why previous generation graphics software interfaces do not meet the needs of today's graphics applications and systems. One type of resource contention issue that sometimes occurs is due to the demands of multipledevices and applications requiring graphics system resources simultaneously. For example, if multiple applications running simultaneously are maintaining connections to multiple surfaces from various objects of the graphics system, sometimes theseconnections to surfaces can become severed or disconnected. When multiple applications have connections between surfaces and objects, more system resources, such as memory space, are utilized resulting in an increased likelihood of a disconnection. Forinstance, while a user may generally toggle back and forth between executing applications, if the connection to surface memory for any one application is severed, a us
An Information System for controlling the well trajectory OTHER DOCS BY Patents-56