I am developing a rendering system which supports automatic,
application-independent time-critical rendering for 3D graphics. When the
scenes being generated overload the rendering engine, a rendering
scheduler employs perception-based techniques to reduce the scene
complexity at run-time. Perception-based degradation mechanisms are used because
they are based on characteristics of the human, not characteristics of the
application. Since the human is the one element guaranteed to exist across all
interactive applications, this rendering system is application-independent.
Given enough cpu-time, present graphics technology can render near
photo-realistic images. However, for real-time graphics applications, developers
must make explicit programming decisions, trading off rendering quality for
interactive update rates. For highly-interactive programs, such as virtual
environment applications, the human perceptual system drives the rendering
requirements, especially the need to maintain a minimum of ten frames per second
or faster. At the same time, developers are trying to present a high-fidelity
graphics environment with a more realistic scene and a richer set of perceptual
cues to help immerse the user. This time/quality conflict forces the developer
to identify when the rendering engine is overloaded and to manually implement
time-critical rendering techniques in order to maintain immersive frame rates.
Previous systems using time-critical rendering techniques rely on
application-specific information to improve frame rates. This restricts the
domain of applications for which this technique is applicable. The developer
must determine whether the given technique is appropriate and then structure the
application to support the required data constructs. This must be performed
manually for each new application. Systems such as Performer [5] and the work by
Funkhouser [3] address this by building in application-independent degradation
mechanisms that automatically execute in order to achieve time-critical
rendering goals.
I am developing a rendering system which performs degradation automatically,
during run-time, as part of the rendering process. This system transparently
separates the application semantics from the rendering process. The
application-independent rendering engine uses a time-driven rendering
scheduler which employs a combination of different perception-based
degradation techniques. Perception-based degradation mechanisms are used because
they are based on characteristics of the human, not characteristics of the
application.
Abstract
Keywords:
virtual reality, virtual environments, time-critical
rendering, rendering scheduler, image degradation, real-time,
application-independence, interactive graphics.
Introduction
PERCEPTION-BASED TECHNIQUES
Perception-based rendering techniques
capitalize on the capabilities and limitations of the human (visual) perception
systems. For example, consider a scene with several objects placed at different
distances from the user. These distances change during run-time based on the
non-deterministic behavior of the user. Objects which are too distant to be
perceived may be removed. From the user's standpoint, this image-degradation is
lossless, even though from an image processing standpoint pixels may have
changed. But as more objects are removed from the distance, the user will begin
to perceive changes to the image -- lossy degradation from the human standpoint.
Perception-based degradation techniques trade off this human-centered definition
of lossiness for increased rendering speed. There are several properties of the
human visual system which may be exploited when performing degradation:
Designing degradation mechanisms around these
perception properties ensures that the time-critical rendering will be
application-independent.
SYSTEM ARCHITECTURE
Many existing virtual environments/graphics systems,
such as Sense8's WorldToolkit [6] and IRIS Inventor [8], work within a single
process. This couples the graphics rendering rate (based on the movement of the
user's head) to the underlying simulation's computation speed. If one were
simulating a billiard table, for example, and the collision detection module
were only capable of calculating at two frames per second, the user's visual
system would be forced to update at two frames per second as well. If I separate
the simulation computation rate from the rendering frames, I gain the ability to
render scenes in real-time, even when simulation computations become more
complicated. See
figure 1:Separation of Application and Rendering.
This model of computation also allows the rendering engine to function independently of the application, and ensures application independence for the rendering engine [4] [7]. To provide automated degradation, a rendering scheduler is embedded within the rendering engine. This scheduler is responsible for determining how much time is available and to what extent to employ the degradation mechanisms.
