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.
