viewmodel.html

JAVA多媒体开发类库说明

<ul>
  <font size="-1"><b><i>Figure 10</i> &#8211; A Three-Screen Display
Environment</b></font>
</ul>
<p>
A multiple-screen environment requires more care during the
initialization and calibration phase. Java&nbsp;3D must know how the
Screen3Ds are placed with respect to one another, the tracking device,
and the physical portion of the coexistence coordinate system.
</p>
<p>
</p>
<h2>Viewing in Head-Tracked Environments</h2>
<p>The "<a href="#Generating_View">Generating a View</a>" section
describes how Java&nbsp;3D generates a view for a standard flat-screen
display with no head tracking. In this section, we describe how
Java&nbsp;3D
generates a view in a room-mounted, head-tracked display
environment-either a computer monitor with shutter glasses and head
tracking or a multiple-wall display with head-tracked shutter glasses.
Finally, we describe how Java&nbsp;3D generates view matrices in a
head-mounted and head-tracked display environment.
</p>
<h3>A Room-Mounted Display with
Head Tracking</h3>
When head tracking combines with a room-mounted
display environment (for example, a standard flat-screen display), the
ViewPlatform's origin and orientation serve as a base for constructing
the view matrices. Additionally, Java&nbsp;3D uses the end-user's head
position and orientation to compute where an end-user's eyes are
located in physical space. Each eye's position serves to offset the
corresponding virtual eye's position relative to the ViewPlatform's
origin. Each eye's position also serves to specify that eye's frustum
since the eye's position relative to a Screen3D uniquely specifies that
eye's view frustum. Note that Java&nbsp;3D will access the PhysicalBody
object to obtain information describing the user's interpupilary
distance and tracking hardware, values it needs to compute the
end-user's eye positions from the head position information.
<h3>A Head-Mounted Display with
Head Tracking</h3>
In a head-mounted environment, the ViewPlatform's origin and
orientation also serves as a base for constructing view matrices. And,
as in the head-tracked, room-mounted environment, Java&nbsp;3D also
uses the
end-user's head position and orientation to modify the ViewPlatform's
position and orientation further. In a head-tracked, head-mounted
display environment, an end-user's eyes do not move relative to their
respective display screens, rather, the display screens move relative
to the virtual environment. A rotation of the head by an end user can
radically affect the final view's orientation. In this situation, Java
3D combines the position and orientation from the ViewPlatform with the
position and orientation from the head tracker to form the view matrix.
The view frustum, however, does not change since the user's eyes do not
move relative to their respective display screen, so Java&nbsp;3D can
compute the projection matrix once and cache the result.
<p>If any of the parameters of a View object are updated, this will
effect
a change in the implicit viewing transform (and thus image) of any
Canvas3D that references that View object.
</p>
<p>
</p>
<h2>Compatibility Mode</h2>
<p>A camera-based view model allows application programmers to think
about
the images displayed on the computer screen as if a virtual camera took
those images. Such a view model allows application programmers to
position and orient a virtual camera within a virtual scene, to
manipulate some parameters of the virtual camera's lens (specify its
field of view), and to specify the locations of the near and far
clipping planes.
</p>
<p>Java&nbsp;3D allows applications to enable compatibility mode for
room-mounted, non-head-tracked display environments or to disable
compatibility mode using the following methods. Camera-based viewing
functions are available only in compatibility mode. The <code>setCompatibilityModeEnable</code>
method turns compatibility mode on or off. Compatibility mode is
disabled by default.
</p>
<hr noshade="noshade">
<p><b>Note:</b> Use of these view-compatibility
functions will disable some of Java&nbsp;3D's view model features and
limit
the portability of Java&nbsp;3D programs. These methods are primarily
intended to help jump-start porting of existing applications.
</p>
<hr noshade="noshade">
<h3>Overview of the
Camera-Based View Model</h3>
The traditional camera-based view model, shown in <a href="#Figure_11">Figure
11</a>,
places a virtual camera inside a geometrically specified world. The
camera "captures" the view from its current location, orientation, and
perspective. The visualization system then draws that view on the
user's display device. The application controls the view by moving the
virtual camera to a new location, by changing its orientation, by
changing its field of view, or by controlling some other camera
parameter.
<p>The various parameters that users control in a
camera-based view model specify the shape of a viewing volume (known as
a frustum because of its truncated pyramidal shape) and locate that
frustum within the virtual environment. The rendering pipeline uses the
frustum to decide which objects to draw on the display screen. The
rendering pipeline does not draw objects outside the view frustum, and
it clips (partially draws) objects that intersect the frustum's
boundaries.
</p>
<p>Though a view frustum's specification may have many items in common
with those of a physical camera, such as placement, orientation, and
lens settings, some frustum parameters have no physical analog. Most
noticeably, a frustum has two parameters not found on a physical
camera: the near and far clipping planes.
</p>
<p><a name="Figure_11"></a><img style="width: 500px; height: 202px;"
 alt="Camera-Based View Model" title="Camera-Based View Model"
 src="ViewModel11.gif">
</p>
<p>
</p>
<ul>
  <font size="-1"><b><i>Figure 11</i> &#8211; The Camera-Based View Model</b></font>
</ul>
<p>
The location of the near and far clipping planes allows the application
programmer to specify which objects Java&nbsp;3D should not draw.
Objects
too far away from the current eyepoint usually do not result in
interesting images. Those too close to the eyepoint might obscure the
interesting objects. By carefully specifying near and far clipping
planes, an application programmer can control which objects the
renderer will not be drawing.
</p>
<p>From the perspective of the display device, the virtual camera's
image
plane corresponds to the display screen. The camera's placement,
orientation, and field of view determine the shape of the view frustum.
</p>
<p>
</p>
<h3>Using the Camera-Based View
Model</h3>
<p>The camera-based view model allows Java&nbsp;3D to bridge the gap
between
existing 3D code and Java&nbsp;3D's view model. By using the
camera-based
view model methods, a programmer retains the familiarity of the older
view model but gains some of the flexibility afforded by Java&nbsp;3D's
new
view model.
</p>
<p>The traditional camera-based view model is supported in Java&nbsp;3D
by
helping methods in the Transform3D object. These methods were
explicitly designed to resemble as closely as possible the view
functions of older packages and thus should be familiar to most 3D
programmers. The resulting Transform3D objects can be used to set
compatibility-mode transforms in the View object.
</p>
<p>
</p>
<h4>Creating a Viewing Matrix</h4>
<p>The Transform3D object provides a <code>lookAt</code> utility
method
to create a
viewing matrix. This method specifies the position and orientation of
a viewing transform. It works similarly to the equivalent function in
OpenGL. The inverse of this transform can be used to control the
ViewPlatform object within the scene graph. Alternatively, this
transform can be passed directly to the View's <code>VpcToEc</code>
transform via the compatibility-mode viewing functions. The <code>setVpcToEc</code><code></code>
method is used to set the viewing matrix when in compatibility mode.
</p>
<h4>Creating a Projection
Matrix</h4>
<p>The Transform3D object provides three methods for
creating a projection matrix: <code>frustum</code>, <code>perspective</code>,
and <code>ortho</code>. All three map points from eye coordinates
(EC) to clipping coordinates (CC). Eye coordinates are defined such
that (0, 0, 0) is at the eye and the projection plane is at <em>z</em>
= -1.<br>
</p>
<p>The <code>frustum</code> method
establishes a perspective projection with the eye at the apex of a
symmetric view frustum. The transform maps points from eye coordinates
to clipping coordinates. The clipping coordinates generated by the
resulting transform are in a right-handed coordinate system (as are all
other coordinate systems in Java&nbsp;3D).
</p>
<p>The arguments define the frustum and its associated perspective
projection: <code>(left</code>, <code>bottom</code>, <code>-near)</code>
and <code>(right</code>, <code>top</code>, <code>-near)</code>
specify the point on the near clipping plane that maps onto the
lower-left and upper-right corners of the window, respectively. The <code>-far</code>
parameter specifies the far clipping plane. See <a href="#Figure_12">Figure
12</a>.
</p>
<p>The <code>perspective</code> method establishes a perspective
projection with the eye at the apex of a symmetric view frustum,
centered about the <em>Z</em>-axis,
with a fixed field of view. The resulting perspective projection
transform mimics a standard camera-based view model. The transform maps
points from eye coordinates to clipping coordinates. The clipping
coordinates generated by the resulting transform are in a right-handed
coordinate system.
</p>
<p>The arguments define the frustum and its associated perspective
projection: <code>-near</code> and <code>-far</code> specify the near
and far clipping planes; <code>fovx</code> specifies the field of view
in the <em>X</em> dimension, in radians; and <code>aspect</code>
specifies the aspect ratio of the window. See <a href="#Figure_13">Figure
13</a>.
</p>
<p><a name="Figure_12"></a><img style="width: 500px; height: 209px;"
 alt="Perspective Viewing Frustum" title="Perspective Viewing Frustum"
 src="ViewModel12.gif">
</p>
<p>
</p>
<ul>
  <font size="-1"><b><i>Figure 12</i> &#8211; A Perspective Viewing Frustum</b></font>
</ul>
<p>
<a name="Figure_13"></a><img style="width: 500px; height: 212px;"
 alt="Perspective View Model Arguments"
 title="Perspective View Model Arguments" src="ViewModel13.gif"></p>
<p>
</p>
<ul>
  <font size="-1"><b><i>Figure 13</i> &#8211; Perspective View Model Arguments</b></font>
</ul>
<p>
The <code>ortho</code> method
establishes a parallel projection. The orthographic projection
transform mimics a standard camera-based video model. The transform
maps points from eye coordinates to clipping coordinates. The clipping
coordinates generated by the resulting transform are in a right-handed
coordinate system.
</p>
<p>The arguments define a rectangular box used for projection: <code>(left</code>,
<code>bottom</code>, <code>-near)</code> and <code>(right</code>, <code>top</code>,
<code>-near)</code>
specify the point on the near clipping plane that maps onto the
lower-left and upper-right corners of the window, respectively. The <code>-far</code>
parameter specifies the far clipping plane. See <a href="#Figure_14">Figure
14</a>.
</p>
<p><a name="Figure_14"></a><img style="width: 500px; height: 220px;"
 alt="Orthographic View Model" title="Orthographic View Model"
 src="ViewModel14.gif">
</p>
<p>
</p>
<ul>
  <font size="-1"><b><i>Figure 14</i> &#8211; Orthographic View Model</b></font>
</ul>
<p>
</p>
<p>The <code>setLeftProjection</code>
and <code>setRightProjection</code> methods are used to set the
projection matrices for the left eye and right eye, respectively, when
in compatibility mode.</p>
</body>
</html>