JP2001043398A - System and method for displaying three-dimensional object for generating object blur while using motion vector - Google Patents

Abstract

PROBLEM TO BE SOLVED: To efficiently simulate an object blur in a three-dimensional(3D) graphics environment by rendering a stationary object just once and executing rendering over series of time slices only concerning a moving object. SOLUTION: When the object is stationary, that object is rendered in a color buffer. A prescribed rendering period is divided into (n) time slices. Time slice count is set to '1'. The moving object is selected and a place, a color and the other all attributes are calculated or corrected for each apex in the object while using the motion vector. Then, the object is rendered in the color buffer. That scene is stored and copied from the color buffer to a storage buffer. When count is equal to (n), the storage buffer is copied to a frame buffer and displayed on a display picture.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

The present invention relates to the field of information processing systems, and more particularly, to systems and methods for displaying three-dimensional objects. More specifically, the present invention relates to using a motion vector to create an object blur effect.

[0002]

2. Description of the Related Art Three-dimensional (3D) graphics systems are used for a variety of applications, including CAD, architectural design, aircraft and other vehicle simulation training equipment, molecular modeling, virtual reality applications, and video games. ing. Three-dimensional systems are often implemented on workstations and personal computers, which may or may not include 3D graphics hardware. In systems that include 3D graphics hardware, a graphics accelerator card typically facilitates the generation and display of graphics images.

[0003] A software application program generates a 3D graphics scene, and describes the scene, along with lighting attributes, with the application application.
Provide to the program interface (API). Current APIs include OpenGL®, PHIGS, and Direct3D®. A 3D graphics scene consists of a number of polygons (polygons) defined by a set of vertices. The vertices combine to form larger primitives, such as triangles or other polygons. Triangles (or polygons) are combined to form surfaces, and the surfaces are combined to form objects. Each vertex is 1) a material color that describes the color of the object to which the vertex belongs, 2) a normal vector that describes the direction the surface is facing at that vertex, and 3) a position that includes three Cartesian coordinates x, y, and z. Associated with a set of attributes, generally including Each vertex may have a texture coordinate or α (ie, transparency)
May be associated with a value. In addition, scenes are generally
It has a set of attributes, including 1) an ambient color that describes the amount of ambient light, and 2) one or more individual light sources. Each light source has a number of attributes, including direction, ambient color, diffuse color and specular color.

In graphics systems, rendering is used to generate a two-dimensional projected image of a 3D graphics scene for display on a monitor or other display device. Typically, rendering is performed on geometric primitives (eg, points, lines, and polygons) by performing one or more of the following operations as needed—transformation, clipping, culling, lighting, fogging calculations, and texture coordinate generation. Processing. Rendering further includes the process of processing primitives to determine component pixel values for a display device (often specifically referred to as "rasterization").

[0005] In some 3D applications, for example in computer animation and simulation programs, objects in the 3D graphics scene may move. In these cases, it is desirable to simulate motion blur for moving objects. Without motion blur, moving objects may appear to move awkwardly on the screen.

Similar techniques are commonly used to simulate objects when simulating depth. Objects within the field of view are not blurred, but closer or more distant objects are blurred according to their distance from the camera (ie, the viewer).

[0007] Prior art methods of simulating object blur involve the use of accumulation (accumulation) buffers. The accumulation buffer is a hidden buffer used to accumulate a series of images as they are rendered. The entire scene (ie, each object or primitive in the scene) is repeatedly rendered in an accumulation buffer over a series of time slices. Thus, the entire scene is stored in the storage buffer and then copied to the frame buffer for viewing on a display.

A prior art method of simulating object blur using a storage buffer is shown in FIG. FIG.
, The period is divided into n time slices (step 100). The time period is the amount of time a scene is seen on the display device, similar to the exposure interval or shutter speed of a video camera shutter. The slower the shutter speed, the more the blur is increased, and the faster the shutter speed, the less the blur. Set the time slice count to 1 (step 10)
2). Next, the object (ie, the primitive)
Is selected for rendering (step 104).
For this particular time slice, the location, color and all other per-vertex values for each vertex in the object are calculated (step 106). Then, the object is rendered in the color buffer (step 10).
8). Determine whether the rendered object is the last object in the scene (step 110). If not, the process loops back to step 104 and repeats for each object in the scene.

If the last object in the scene has been rendered (ie, if the answer to the question in step 110 is yes), the scene is stored (step 112). That is, the scene is scaled (eg, x1 / n) and copied into the accumulation buffer.
Check the time slice count and find that it is n
Is checked (step 114). If not, increment the time slice count (step 116). The process then proceeds to step 104
And it repeats every time slice. If the time slice count is equal to n (ie, the answer to the question of step 114 is yes
), Scale the accumulation buffer,
The data is copied to a buffer (step 120) and displayed on a display screen (step 122).

[0010]

The use of the accumulation buffer described in FIG. 1 is a computationally expensive process because it renders the entire scene (ie, each object in the scene) n times per period. . As a result, it would be desirable to have systems and methods for more efficiently simulating object blur in a three-dimensional graphics environment.

[0011]

SUMMARY OF THE INVENTION Accordingly, the present invention provides
Systems, methods, and computer-usable media for simulating object blur using motion vectors. Motion vectors or arrays of motion vectors can be specified on a per-vertex or per-primitive (ie, per-object) basis. The motion vector is opposite to the direction of motion and thus points to the direction of blur. The magnitude of the motion vector represents the distance that a vertex or a primitive (that is, each vertex in the primitive) moves per unit time.

When a scene is rendered, only objects that are moving or blurred in response to depth are rendered over a series of time slices. All objects that are stationary (ie, not blurred) are rendered directly into the color buffer rather than being repeatedly rendered over a series of time slices. In this way, stationary (ie, not blurred) objects are rendered only once, and blurred objects are rendered over a series of time slices. This increases the efficiency of the rendering process while simulating object blur for the objects to be blurred.

[0013]

FIG. 2 shows a typical system capable of realizing the present invention. Information processing system 200
Includes one or more processors 202 coupled to a processor bus or host bus 204. Also, cache memory 206 may be coupled to host bus 204. A bridge / memory controller 208 is coupled between the host bus 204 and the peripheral bus 212 in parallel with the system memory 210. System memory 210 may include both read-only memory (ROM) and random access memory (RAM). The storage buffer 214 is included in the system memory 210. Alternatively, the accumulation buffer 214
May also be included in the graphics adapter 218. In one embodiment, peripheral bus 212 is a PCI bus or other bus suitable for supporting high performance graphics applications and hardware. Graphics adapter 218 is peripheral bus 21
2 and may include a local memory 220 and a frame buffer 221. The system 200 may or may not include the graphics adapter 218, and if the graphics adapter 218 is not present in the system 200, includes the frame buffer 221 in the system memory 210 or the video controller 216. be able to. Video control device 2
16 is coupled to the display 222 and is configured to refresh the display 222 with the graphics images stored in the frame buffer 221.
Graphics adapter 218 may preferably be integrated with video controller 216.

The present invention is a system, method and computer usable medium for simulating object blur using motion vectors. Motion vectors or arrays of motion vectors can be specified on a per-vertex or per-primitive (ie, per-object) basis. The motion vector is opposite to the direction of motion and thus points to the direction of blur. The magnitude of the motion vector represents the distance that a vertex or a primitive (that is, each vertex in the primitive) moves per unit time.

When a scene is rendered, only moving objects are rendered over a series of time slices. All objects that are stationary (ie, do not move) are rendered directly into the color buffer rather than being repeatedly rendered over a series of time slices. In the prior art, each object in the scene (whether stationary or moving) is accumulated after being rendered over a series of time slices, as discussed in "Prior Art". The present invention renders a static object only once and performs the rendering over a series of time slices only for moving objects. This increases the efficiency of the rendering process while simulating object blur for moving objects. The present invention can also be used to simulate object blur as a function of depth.

Next, an example of an object that moves linearly in a still scene will be described with reference to FIG. In a typical scene, many objects can have motion, but for illustrative purposes, FIG. 3 shows a single object 300 with motion in a static scene 302.
Is shown. The motion vector 304 is in the opposite direction to the direction of motion 306. The magnitude of the motion vector 304 indicates the distance that the object 300 moves during a predetermined period. FIG.
In the example shown in (1), one motion vector 304 is specified for this object. Therefore, the motion vector 304 applies to each vertex of the object 300. Within a predetermined period, the vertex of the object 300 is
The points have moved from 1, b1 and c1 to points a2, b2 and c2, respectively. Therefore, the magnitude of the motion vector 304 is equal to a2-a1. This size is also b2-b
1 and equal to c2-c1.

Naturally, each vertex of the object 300 need not move at the same speed. It is also possible to assign a different motion vector to each vertex of the object. Each vertex may move in a different direction or at a different speed.

Next, an example of an object that moves nonlinearly in a still scene will be described with reference to FIG.
3, only one moving object is shown in the still scene 402 for illustrative purposes. A plurality of motion vectors 404, 40 associated with the object 400
6, 408 and 410. Each motion vector has a magnitude equal to a part of the distance that the object 400 has moved within a predetermined period. In the example shown, each motion vector 404, 406, 408, and 410 applies to each vertex of the object 400. Within a predetermined period, the vertices of the object 400 move from the points a1, b1 and c1 to the points a2, b2 and c2, respectively. Each vertex moves equally with the other vertices, but the object 400
(And its vertices) do not move linearly. Therefore, each motion vector 404, 406, 408 and 41
0 includes a magnitude equal to the distance traveled during a portion of the predetermined period. As in FIG. 3, each motion vector is in the opposite direction to the direction of motion 412. Motion vector 404,4
06, 408 and 410 are collectively referred to as an "array of motion vectors". An array of motion vectors can be assigned to the object as shown in FIG. 4, where the array of motion vectors applies to each vertex in the object. Alternatively, an array of motion vectors may be assigned to one vertex.

Preferably, an application program interface (API) is provided so that the application program can specify motion vectors for objects and vertices. As an example
The OpenGL API is described below. This API is illustrative only and should not be considered limiting. Those skilled in the art will appreciate that a variety of programming techniques can be used to specify the motion vectors. Furthermore, AP
The use of OpenGL as I is not considered limiting. The present invention relates to various A, including PHIGS and Direct3-D.
It can be implemented using PI.

An example of the OpenGL API is as follows. Overview This extension allows object blurring to occur at points, lines or edges along a specified motion vector. The motion vector is in the opposite direction to the direction of motion, and thus points to the direction of blur. The magnitude of the vector is the distance that each vertex has moved in unit time. The "glMotionVector *" routines allow an application to specify a motion vector or an array of motion vectors on a vertex or primitive basis. The "glMotionEnv *" routines determine the duration of the application, the degree of temporal fade, and motion blur (ie, object blur).
Allows you to specify whether to enable or disable.

Procedures and Functions void glMotionVector [bsifd] IBM (T xcomponent, yc
omponent, zcomponent) Purpose: Specifies the motion vector of the object. Variables: three bytes specifying a 3D vector, shortword, integer, floating point or double precision floating point. void glMotionVectorv [bsifd] IBM (T components) Purpose: To specify the vertex motion vector. Variable: array specifying 3D vector void glMotionVectorPointerIBM (int size, enum t
ype, sizeistride, void * pointer) Purpose: Specifies an array of motion vectors for an object or vertex. 3. Variable: size, type and stride of the list of motion vectors pointed to by the pointer variable. void glMotionEnv [if] IBM (GLenum pname, GLfloat
param) Purpose: To specify the period and degree of blur. Variable: If pname is equal to GL_MOTION_ENV_FADE_IBM, param specifies the degree to which the object will fade in time. pname is GL_MOTION_ENV_DELTA_TIME_IB
If equal to M, param specifies the number of unit times at which blur occurs.

Referring to FIGS. 5 and 6, a flowchart illustrating a method for simulating object blur using a motion vector according to the present invention will be described. FIG.
6 can be performed in either software or hardware (eg, with a graphics accelerator) or a combination of software and hardware. Objects in the scene are defined for rendering (step 500). That is, the location, color, motion vector, and other attributes of the object are defined. The scene environment is used with the motion vectors associated with the object to determine whether the object is stationary or moving (step 502). The determination at step 502 may further include determining whether the object must be blurred according to its depth. If the object is not stationary (ie, the answer to the question in step 504 is no), the object is identified as a "moving" object (step 506). If the object is stationary (ie, the answer to the question in step 504 is yes), render the object in a color buffer (step 508). The color buffer may be an optional buffer area. For example, the color buffer may be part of system memory 210 or local memory 220 on graphics adapter 218, as described above with reference to FIG.

Referring again to FIGS. 5 and 6, a determination is made whether the object is the last object in the scene (step 510). If it is not the last object (ie, the answer to the question in step 510 is no), then in step 500 another object is defined for rendering. If the object is the last object in the scene (ie, the answer to the question in step 510 is yes), the moving object (ie, the object that needs blurring) is processed. If you are skilled in the art,
If there are no moving objects in the scene, it will be appreciated at this point that the color buffer may be copied to the frame buffer and the scene displayed. For purposes of illustration, the processes shown in FIGS. 5 and 6 assume that the scene contains a mixture of stationary and moving objects.

A given rendering period is defined by n time
It is divided into slices (step 512). As discussed above with reference to FIG. 1, the rendering period is the total time that the scene is visible on the display screen, and
Similar to shutter exposure interval or shutter speed. The time slice count is set to 1 (step 514). Next, a moving object (ie, an object identified as a "moving" object in step 506) is selected for rendering (step 516). The location, color and all other attributes are calculated or modified for each vertex in the object using the motion vector associated with the object along with other motion variables (step 518). Then, the object is rendered in the color buffer (step 520). It is determined whether the rendered object is the last "moving" object in the scene (step 522). If not, the process loops back to step 516 and repeats for each "moving" object in the scene.

If the last "moving" object in the scene has been rendered (ie, the answer to the question in step 522 is yes), the scene is stored (step 524). That is, it is scaled (eg, x1 / n) and copied from the color buffer to the storage buffer. Check the time slice count to see if it is equal to n (step 526). If not, increment the time slice count (step 528). The process then loops back to step 516 and repeats for each time slice. If the time slice count is equal to n (ie, the answer to the question in step 528 is yes), the accumulation buffer is scaled and copied to the frame buffer (step 53).
2) Display on the display screen (step 534).

It is possible to define two entry points to the method described in FIGS. 5 and 6, or alternatively, two separate routines for performing the method described in FIGS. It is possible to have
For example, a determination of whether an object is moving (ie, must be blurred) can be made by an application program. If the application program determines that the object is stationary, it can perform only steps 500-510 and call a routine that renders only stationary objects. If the application program determines that the object must be blurred, it can execute only steps 512-534 and call a routine that renders only moving objects.

Although the invention has been described in some detail,
It will be appreciated that those skilled in the art can change the elements without departing from the spirit and scope of the invention. One embodiment of the present invention is a random access system of one or more computer systems configured as described in FIG.
It is in the form of a set of instructions resident in memory.
The instruction set is stored in another computer-readable memory, such as a hard disk drive, or a removable memory, such as an optical disk or floppy for use in a CD-ROM drive, until required by the computer system. ) May be stored on a floppy disk for use in a disk drive. In addition, the instruction set may be stored in the memory of another computer so that, when desired by the user, a local area network or wide area network.
It can also be transmitted over an area network, for example the Internet. One skilled in the art understands that the physical storage of the instruction set physically changes the medium on which the instruction set is stored electrically, magnetically or chemically, such that the medium carries computer usable information. Will do. The invention is limited only by the claims and the equivalents thereof.

In summary, the following matters are disclosed regarding the configuration of the present invention. (1) A method for displaying a three-dimensional graphics scene including a plurality of objects, wherein the plurality of objects is a first set of objects including one or more objects to be blurred, and one or more objects are not blurred. Classifying the objects in the second set of objects into a second set of objects, and rendering each object in the second set of objects directly into a first buffer; and rendering the rendering period into a plurality of time slices. The steps of dividing and for each time slice,
Rendering each object in the first set of objects in the first buffer and storing a three-dimensional graphics scene from the first buffer in a storage buffer; Displaying the scene. (2) the step of classifying comprises determining whether a motion vector is associated with the selected object; and if the motion vector is associated with the selected object, identifying the selected object. (1) assigning the selected object to the second object set if a motion vector assigned to the first object set is not associated with the selected object. the method of. (3) The method of (2) above, wherein said determining comprises determining whether a motion vector is associated with a vertex of said selected object. (4) The method according to (2), wherein the motion vector has a direction opposite to a direction of the motion of the selected object. (5) The method according to (2), wherein the length of the motion vector is proportional to the speed of the motion of the selected object. (6) the displaying step includes copying the accumulation buffer to a frame buffer; and displaying the contents of the frame buffer on a display device.
The method according to the above (1), further comprising: (7) display means, a plurality of objects displayed as a three-dimensional graphics scene on the display means, a first object set including one or more objects to be blurred, and Means for classifying into a second set of objects including one or more objects that are not exposed, and means for rendering each object in the second set of objects directly into a first buffer; Means for dividing the rendering period into a plurality of time slices;
Means for rendering each object in the first set of objects in the first buffer during each time slice; and three-dimensional graphics from the first buffer during each time slice. An information processing system comprising: means for storing a scene in a storage buffer; and means for displaying the three-dimensional graphics scene on the display device. (8) the means for categorizing comprises: means for determining whether a motion vector is associated with the selected object; and if the motion vector is associated with the selected object, the selecting Means for assigning the selected object to the first set of objects and, if no motion vector is associated with the selected object, assigning the selected object to the second set of objects; (7) The information processing system according to the above (7). (9) The information processing system according to (8), wherein the means for determining includes a means for determining whether a motion vector is related to a vertex of the selected object. (10) The information processing system according to (8), wherein the motion vector has a direction opposite to a direction of the motion of the selected object. (11) The information processing system according to (8), wherein the length of the motion vector is proportional to the speed of movement of the selected object. (12) The means for displaying further includes means for copying the accumulation buffer to a frame buffer, and means for displaying the contents of the frame buffer on the display means. The information processing system according to (1). (13) A computer usable medium having recorded thereon a program for displaying a three-dimensional graphics scene on a display device, wherein the program includes a plurality of objects including one or more objects to be blurred. Means for classifying into an object set and a second object set comprising one or more objects that are not blurred, and rendering each object in said second object set directly into a first buffer The rendering period and multiple time periods.
Means for dividing into slices, means for rendering each object in the first set of objects in the first buffer during each time slice, and means for rendering the first object in each time slice. A computer-usable medium comprising: means for accumulating a three-dimensional graphics scene from a buffer in a storage buffer; and means for displaying the three-dimensional graphics scene on the display device. (14) the program means for determining whether a motion vector is associated with the selected object; and, if the motion vector is associated with the selected object, the program determines the selected object. Means for assigning to the first set of objects, and if no motion vector is associated with the selected objects, assigning the selected objects to the second set of objects. (13) The computer usable medium according to (13). (15) The computer usable medium of (14), wherein the means for determining includes means for determining whether a motion vector is associated with a vertex of the selected object. (16) The computer usable medium according to (14), wherein the motion vector has a direction opposite to a direction of the motion of the selected object. (17) The computer usable medium according to (14), wherein the length of the motion vector is proportional to the speed of movement of the selected object. (18) The means (13), wherein the means for displaying further includes means for copying the accumulation buffer to a frame buffer, and means for displaying the contents of the frame buffer on a display device. A computer usable medium as described.

[Brief description of the drawings]

FIG. 1 is a flow diagram illustrating a prior art method of simulating object blur.

FIG. 2 is a diagram showing a representative system capable of implementing the present invention.

FIG. 3 is a diagram showing an object moving in a still scene together with a motion vector.

FIG. 4 is a diagram showing an object moving in a still scene together with an array of motion vectors.

FIG. 5 is a flowchart illustrating a method for simulating object blur using motion vectors according to the present invention.

FIG. 6 is a flowchart illustrating a method for simulating object blur using motion vectors according to the present invention.

[Explanation of symbols]

 200 Information Processing System 202 Processor 204 Host Bus 206 Cache Memory 208 Bridge / Memory Controller 210 System Memory 212 Peripheral Bus 214 Storage Buffer 216 Video Controller 218 Graphics Adapter 220 Local Memory 221 Frame Buffer 222 Display

 ────────────────────────────────────────────────── ─── Continued on the front page (72) Inventor Irais Clare Certowski Lakeway Drive 414, Austin, Texas, United States 77834 Inventor Charles Ray John United States 78759 Austin, Cassia, Texas Drive 10703 (72) Inventor Barry El Minnow United States 78730 Merry Wing Crown, Austin, Texas 5501 (72) Inventor George Leopold White Jr. United States 78745 Austin, Texas, Gallop Cove 3311

Claims (18)

[Claims] A method for displaying a three-dimensional graphics scene including a plurality of objects, the method comprising: displaying a plurality of objects on a first set of objects including one or more objects to be blurred; A second object containing more than one object
Classifying each object in the second set of objects directly into a first buffer; dividing the rendering period into a plurality of time slices; each time slice; The first object
Rendering each object in the set in the first buffer and storing a three-dimensional graphics scene from the first buffer in a storage buffer; and displaying the three-dimensional graphics scene. And a method comprising: 2. The step of categorizing comprises: determining whether a motion vector is associated with a selected object; and, if a motion vector is associated with the selected object, selecting the selected object. Assigning an object to the first set of objects, if the motion vector is not associated with the selected object, assigning the selected object to the second set of objects. The described method. 3. The method of claim 2, wherein said determining includes determining whether a motion vector is associated with a vertex of said selected object. 4. The method of claim 2, wherein said motion vector is in a direction opposite to a direction of motion of said selected object. 5. The method of claim 2, wherein the length of said motion vector is proportional to the speed of movement of said selected object. 6. The method of claim 1, wherein said displaying further comprises: copying the accumulation buffer to a frame buffer; and displaying the contents of the frame buffer on a display device. 7. A display means, a plurality of objects displayed as a three-dimensional graphics scene on the display means, and a first object set including one or more objects in which the plurality of objects are blurred. Means for classifying the objects into a second set of one or more objects that are not blurred; and means for rendering each object in the second set of objects directly into a first buffer. Means for dividing the rendering period into a plurality of time slices; means for rendering each object in the first set of objects in the first buffer during each time slice; Store the 3D graphics scene from the first buffer during each time slice. The information processing system comprising: means for storing in the file, and means for displaying said three-dimensional graphics scene on the display device. 8. The means for categorizing comprises: means for determining whether a motion vector is associated with a selected object; and if a motion vector is associated with the selected object, Means for assigning the selected object to the first set of objects, and if the motion vector is not associated with the selected object, assigning the selected object to the second set of objects The information processing system according to claim 7, comprising: 9. The information processing system according to claim 8, wherein said means for determining includes means for determining whether a motion vector is associated with a vertex of said selected object. 10. The information processing system according to claim 8, wherein the motion vector has a direction opposite to a direction of the motion of the selected object. 11. The information processing system according to claim 8, wherein a length of said motion vector is proportional to a speed of movement of said selected object. 12. The display means further comprises: means for copying the storage buffer to a frame buffer; and means for displaying the contents of the frame buffer on the display means. Item 8. The information processing system according to Item 7. 13. A computer usable medium having recorded thereon a program for displaying a three-dimensional graphics scene on a display device, said program comprising a plurality of objects including one or more objects to be blurred. Means for classifying into one set of objects and a second set of objects including one or more objects that are not blurred; each object in said second set of objects being stored in a first buffer. Means for direct rendering; means for dividing a rendering period into a plurality of time slices; and rendering each object in the first set of objects in the first buffer during each time slice. Means for performing the third order from the first buffer during each time slice. Means for storing the graphics scene during the accumulation buffer, computer usable medium and means for displaying said three-dimensional graphics scene on the display device. 14. The program further comprises: means for determining whether a motion vector is associated with the selected object; and if the motion vector is associated with the selected object, the selected Means for assigning an object to the first set of objects, and if no motion vector is associated with the selected object, further assigning the selected object to the second set of objects. 14. The computer usable medium of claim 13 comprising. 15. The computer-usable medium of claim 14, wherein said means for determining comprises means for determining whether a motion vector is associated with a vertex of said selected object. 16. The motion vector of claim 14, wherein the motion vector has a direction opposite to a direction of motion of the selected object.
A computer usable medium as described. 17. The computer usable medium of claim 14, wherein the length of said motion vector is proportional to the speed of movement of said selected object. 18. The apparatus of claim 18, wherein said means for displaying further comprises: means for copying said storage buffer to a frame buffer; and means for displaying the contents of said frame buffer on a display device. 14. The computer usable medium of claim 13.