Data processing: software development – installation – and managem – Software program development tool – Translation of code
Reexamination Certificate
1998-04-08
2003-06-10
Morse, Gregory (Department: 2122)
Data processing: software development, installation, and managem
Software program development tool
Translation of code
C717S140000, C717S141000, C717S142000, C717S144000
Reexamination Certificate
active
06578197
ABSTRACT:
BACKGROUND OF THE INVENTION
1. Field of the Invention
The present invention relates generally to the field of computer graphics, and more specifically to providing a system and method for executing platform-efficient graphics application programs including platform-independent shading language instructions.
2. Related Art
Graphics applications which demand high-quality (photo realistic) shaded rendering (e.g., entertainment industry applications) are typically written using a shading language. Shaded rendering refers to the process of generating a synthetic graphical image of a scene from a mathematical (i.e., geometric and other characteristics) model of the scene, whereas shading refers to the process of computing the light that leaves a point either by self-emission or propagation.
Shading models are mathematical functions that characterize the light leaving a particular point on a surface or in a space. In early development, one was required to select a particular model, characterized by its set of mathematical equations, and select parameters to accomplish rendering. A user was required to intimately know the model and fine tune the parameters to be successful. These models were thus labeled parametric shading models (of which expressions were labeled parametric shading expressions).
Shading languages developed from the need to utilize custom shading models (i.e., a “shader”). A high-level shade tree architecture for building customized shaders was first described in Cook,
Shade Trees,
Computer Graphics (SIGGRAPH '84 Proceedings), H. Christiansen, (Ed.), Vol. 18, No. 3, pp. 223-231 (July 1984), which is incorporated herein by reference in its entirety. Cook described an architecture where the shading process was broken down into a number of basic operations which could be organized in a tree-like structure—generally a directed acyclic graph (DAG). Each tree node is basically a function call and a shade tree language program would pass a standard list of parameters to the shade tree, traverse it in post-order, and expect a final color and opacity value to be returned from the root of the tree.
In Perlin,
An Image Synthesizer,
Computer Graphics (SIGGRAPH '85 Proceedings), Vol. 19, No. 3, pp. 287-296 (July 1985), which is incorporated herein by reference in its entirety, a similar language-based approach to shading was presented where arbitrary expressions generated pictures from pre-computed visibility information. The ideas of Cook and Perlin were combined in Hanrahan et al.,
A Language for Shading and Lighting Calculations,
Computer Graphics (SIGGRAPH '90 Proceedings), F. Baskett, (Ed.), Vol. 24, No. 4, pp. 289-298 (Aug.1990), which is incorporated herein by reference in its entirety. The result of that work was the RenderMan™ Shading Language which is well-known in the relevant art. RenderMan™ is described in detail in Upstill,
The Render Man™ Companion,
Addison-Wesley Publishing Co. (USA 1990), which is incorporated herein by reference in its entirety.
It has always been deemed desirable for shading languages to be platform independent. In other words, their designs have aimed to make it more or less possible to port shaded rendering applications among different hardware platforms, without substantially rewriting the source code version of the shading language instructions. To achieve platform independence, shading language instructions are typically handled by compiling and linking the application to software libraries written in a high-level, platform-independent programming language (e.g., the “C” or “C++” programming languages), or by using run-time software interpreters similarly written in a high-level language.
Shading languages, via their abstract high-level procedural shading expressions, typically allow programmers to control the display color and opacity of points within a given surface in a flexible and powerful way. For example, a typical set of RenderMan™ Shading Language instructions for a surface that is to be rendered with constant opacity and color is shown in Table 1.
TABLE 1
surface
constant( )
{
Oi = Os;
Ci = Os * Cs;
}
In this simple illustration of a surface shader, the variable Oi represents the surface opacity, and is set to a constant value—Os. Ci represents the output color, and is set to the product of the constants Cs (surface reflectance) and Os.
In another example, shown in Table 2, a “plastic” surface is specified through a more complex series of RenderMan™ shading instructions, which requires taking various lighting-based computations (e.g., diffusion, specular, ambient, etc.) and combining them mathematically.
TABLE 2
surface
plastic(
float Ks=0.5, Kd=0.5, Ka=1, roughness=0.1;
color specularcolor=1)
{
point Nf = faceforward( normalize(N), I );
point V = normalize(−I);
Oi = Os;
Ci = Os * ( Cs * (Ka*ambient( ) + Kd*diffuse(Nf)) +
specularcolor * Ks * specular(Nf,V,roughness) );
}
Together, these instructions model a plastic surface as a solid medium with microscopic colored particles suspended within it. The specular highlight is assumed to be reflected directly off the surface, and the surface color is assumed to be due to the light entering the medium, reflecting off the suspended particles, and re-emerging.
In any event, the examples contained in Table 1 and Table 2 are standard shaders in the RenderMan™ Shading Language which are easily understood by persons skilled in the relevant art.
A current limitation of executing applications with shaded rendering is that they are painfully slow. Conventional graphics hardware systems can easily take several hours or more to render a single, fully-shaded image frame, for a three-dimensional scene of average complexity. This is currently true even for high-end computer graphics systems containing special purpose 3D graphics hardware such as a state-of-the art Silicon Graphics, Inc.'s Onyx2™ workstations equipped with InfiniteReality graphics. Because shading language instructions are typically compiled and linked using a high-level, platform-independent programming language, the net effect is that the operations required by each shading routine are ultimately handled by the general-purpose microprocessor(s) in the user's computer system. The special-purpose graphics hardware resources in Onyx2™ systems or the like, are simply not tapped.
Furthermore, shading languages, and. graphics application program interfaces (APIs) in general, provide abroad set of primitive commands to specify graphics computations in an ostensibly device-independent manner. However, a limitation of such APIs is that they often allow many distinct, but functionally equivalent, sequences of primitive commands to perform a given computation. The optimal choice, in terms of overall execution time and system resource utilization, among a set of functionally equivalent sequences depends strongly on the underlying hardware or software implementation of the API. This fact undermines the utility of the API as a device abstraction since the programmer must construct distinct sequences for each distinct graphics device in order to achieve optimal performance.
Given the above-described limitations, what is needed is a way of utilizing special purpose graphics hardware resources in order to efficiently execute shaded rendering applications, while preserving the relative platform-independence of such applications. Further, what is needed is a cost-based, run-time compilation system for generating efficient sequences of graphics device commands from an abstract, device-independent computational expression.
SUMMARY OF THE INVENTION
The present invention is a system and method for high-speed execution of graphics application programs, including shading language instructions. The method involves the steps of expressing a graphics computation in a platform-independent procedural shading expression, translating it into an intermediate representation such as a tree and then
Airey John M.
Brandt Jonathan
Peercy Mark
Morse Gregory
Silicon Graphics Inc.
Sterne Kessler Goldstein & Fox P.L.L.C.
Vo Ted T.
LandOfFree
System and method for high-speed execution of graphics... does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with System and method for high-speed execution of graphics..., we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and System and method for high-speed execution of graphics... will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-3151577