Computer graphics processing and selective visual display system – Computer graphic processing system – Graphic command processing
Reexamination Certificate
2001-03-01
2004-12-07
Bella, Matthew C. (Department: 2676)
Computer graphics processing and selective visual display system
Computer graphic processing system
Graphic command processing
C345S419000, C345S537000, C345S538000
Reexamination Certificate
active
06828975
ABSTRACT:
FIELD OF THE INVENTION
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 INVENTION
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'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 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'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'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'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'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 add
Nguyen Hau
Woodcock & Washburn LLP
LandOfFree
Method and system for managing graphics objects in a... does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with Method and system for managing graphics objects in a..., we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Method and system for managing graphics objects in a... will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-3271863