| java.lang.Object
 com.sun.j3d.utils.universe.ViewInfo
| ViewInfo | | public class ViewInfo (Code) | | Provides methods to extract synchronized transform information from a View.
These transforms are derived from application scene graph information, as
opposed to similar core Java 3D methods that derive transforms from
internally maintained data. This allows updates to the scene graph to be
synchronized with the current view platform position.
The architecture of the Java 3D 1.3 sample implementation introduces a
frame latency between updates to the application scene graph structure and
their effects on internal Java 3D state. getImagePlateToVworld
and other methods in the core Java 3D classes use a transform from view
platform coordinates to virtual world coordinates that can be out of date
with respect to the state of the view platform as set by the application.
When an application uses the transforms returned by those methods to update
view dependent parts of the scene graph, those updates might not be
synchronized with what the viewer actually sees.
The methods in this class work around this problem at the expense of
querying the application state of the scene graph to get the current
transform from view platform to virtual world coordinates. This can
involve a potential performance degradation, however, since the application
scene graph state is not designed for high performance queries. The view
platform must also have ALLOW_LOCAL_TO_VWORLD_READ capability
set, which potentially inhibits internal scene graph optimization.
On the other hand, application behaviors that create the view platform
transformation directly will have access to it without the need to query it
from the scene graph; in that case, the transforms from physical
coordinates to view platform coordinates provided by this class are all
that are needed. The ALLOW_LOCAL_TO_VWORLD_READ view platform
capability doesn't need to be set for these applications.
Other Synchronization Issues
Scene graph updates are guaranteed to take effect in the same frame only
if run from the processStimulus() method of a Behavior. Updates from
multiple behaviors are only guaranteed to take effect in the same frame if
they're responding to a WakeupOnElapsedFrames(0) condition. Use a single
behavior to perform view dependent updates if possible; otherwise, use
WakeupOnElapsedFrames(0) and set behavior scheduling intervals to ensure
that behaviors that need the current view platform transform are run after
it's set. Updating scene graph elements from anything other than the
Behavior thread, such as an external input thread or a renderer callback
in Canvas3D, will not necessarily be synchronized with rendering.
Direct updates to geometry data have a different frame latency than
updates to scene graph transforms and structure. In the Java 3D 1.3
architecture, updates to by-reference geometry arrays and texture data have
a 1-frame latency, while updates to transforms and scene graph structure
have a 2-frame latency. Because of bug 4799494, which is outstanding
in Java 3D 1.3.1, updates to by-copy geometry arrays also have a 1-frame
latency. It is therefore recommended that view dependent scene graph
updates be limited to transforms and scene graph structure only.
If it is not possible to avoid updating geometry directly, then these
updates must be delayed by one frame in order to remain synchronized with
the view platform. This can be accomplished by creating an additional
behavior to actually update the geometry, separate from the behavior that
computes the changes that need to be made based on current view state. If
the update behavior is awakened by a behavior post from the computing
behavior then the update will be delayed by a single frame.
Implementation Notes
This utility is essentially a rewrite of a few private Java 3D core
classes, but designed for public use and source code availability. The
source code may be helpful in understanding some of the more complex
aspects of the view model, especially with regards to various interactions
between attributes which are not adequately documented. None of the actual
core Java 3D source code is used, but the code is designed to comply with
the view model as defined by the Java 3D Specification, so it can be
considered an alternative implementation. This class will produce the
same results as the Java 3D core implementation except for:
- The frame latency issue for virtual world transforms.
- Active clip node status. If a clip node is active in the scene graph,
it should override the view's back clip plane. This class has no such
information, so this can't be implemented.
- "Infinite" view transforms for background geometry. These are simply
the rotation components of the normal view transforms with adjusted
clip planes. Again, this function depends upon scene graph content
inaccessible to this class.
- Small floating point precision differences resulting from the
alternative computations.
- Bugs in this class and the Java 3D core.
- Tracked head position.
The last item deserves some mention. Java 3D provides no way to directly
query the tracked head position being used by the renderer. The View's
getUserHeadToVworld method always incorporates a virtual world
transform that is out of date with respect to the application scene graph
state. ViewInfo reads data from the head tracking sensor directly, but
since head trackers are continuous input devices, getting the same data
that the renderer is using is unlikely. See the source code for the
private method getHeadInfo in this class for more information
and possible workarounds.
Thread Safety
All transforms are lazily evaluated. The updateScreen,
updateCanvas, updateViewPlatform,
updateView, and updateHead methods just set flags
indicating that derived transforms need to be recomputed; they are safe to
call from any thread. updateCanvas, for example, can safely
be called from an AWT event listener.
Screens and view platforms can be shared between separate views in the Java
3D view model. To remain accurate, ViewInfo also allows this sharing.
Since it is likely that a multi-view application has separate threads
managing each view, potential concurrent modification of data associated
with a screen or a view platform is internally synchronized in this class.
It is safe for each thread to use its own instance of a ViewInfo
corresponding to the view it is managing.
Otherwise, none of the other methods in this class are internally
synchronized. Except for the update methods mentioned above, a single
instance of ViewInfo should not be used by more than one concurrent thread
without external synchronization.
since:
Java 3D 1.3.1 |
| Field Summary | |
| final public static int | CANVAS_AUTO_UPDATE
Indicates that updates to a Canvas3D associated with the View should
be automatically checked with each call to a public method in this
class. | | final public static int | HEAD_AUTO_UPDATE
Indicates that updates to the tracked head position should be
automatically checked with each call to a public method in this class. | | final public static int | PLATFORM_AUTO_UPDATE
Indicates that updates to the ViewPlatform localToVworld
transform should be automatically checked with each call to a public
method in this class. | | final public static int | SCREEN_AUTO_UPDATE
Indicates that updates to a Screen3D associated with the View should
be automatically checked with each call to a public method in this
class. | | final public static int | VIEW_AUTO_UPDATE
Indicates that updates to the View should be automatically checked
with each call to a public method in this class. |
| Constructor Summary | |
| public | ViewInfo(View view)
Creates a new ViewInfo for the specified View.
Applications are responsible for informing this class of changes to the
View, its Canvas3D and Screen3D components, the tracked head position,
and the ViewPlatform's localToVworld transform. | | public | ViewInfo(View view, int autoUpdateFlags)
Creates a new ViewInfo for the specified View. | | public | ViewInfo(View view, int autoUpdateFlags, Map screenMap, Map viewPlatformMap)
Creates a new ViewInfo for the specified View. |
| Method Summary | |
| public static synchronized void | clear()
Release all static memory references held by ViewInfo, if any. | | public void | getCoexistenceToImagePlate(Canvas3D c3d, Transform3D coe2ipl, Transform3D coe2ipr)
Gets the current transforms from coexistence coordinates to image plate
coordinates and copies them into the given Transform3Ds. | | public void | getCoexistenceToViewPlatform(Canvas3D c3d, Transform3D coe2vp)
| | public void | getCoexistenceToVworld(Canvas3D c3d, Transform3D coe2vw)
| | public void | getEyeToImagePlate(Canvas3D c3d, Transform3D e2ipl, Transform3D e2ipr)
Gets the transforms from eye coordinates to image plate coordinates and
copies them into the Transform3Ds specified.
When head tracking is used the eye positions are taken from the head
position and set in relation to the image plates with each Screen3D's
trackerBaseToImagePlate transform. Otherwise the window
eyepoint policy is used to derive the eyepoint relative to the image
plate. | | public void | getEyeToViewPlatform(Canvas3D c3d, Transform3D e2vpl, Transform3D e2vpr)
Gets the current transforms from eye coordinates to view platform
coordinates and copies them into the given Transform3Ds.
With a monoscopic canvas the eye transform is copied to the first
argument and the second argument is not used. | | public void | getEyeToVworld(Canvas3D c3d, Transform3D e2vwl, Transform3D e2vwr)
Gets the current transforms from eye coordinates to virtual world
coordinates and copies them into the given Transform3Ds.
With a monoscopic canvas the eye transform is copied to the first
argument and the second argument is not used. | | protected Transform3D | getHeadTrackerToTrackerBase()
Returns a reference to a Transform3D containing the current transform
from head tracker coordinates to tracker base coordinates. | | public void | getImagePlateToViewPlatform(Canvas3D c3d, Transform3D ip2vpl, Transform3D ip2vpr)
Gets the current transforms from image plate coordinates to view
platform coordinates and copies them into the given Transform3Ds.
With a monoscopic canvas the image plate transform is copied to the
first argument and the second argument is not used. | | public void | getImagePlateToVworld(Canvas3D c3d, Transform3D ip2vwl, Transform3D ip2vwr)
Gets the current transforms from image plate coordinates to virtual
world coordinates and copies them into the given Transform3Ds.
With a monoscopic canvas the image plate transform is copied to the
first argument and the second argument is not used. | | public void | getInverseProjection(Canvas3D c3d, Transform3D cc2el, Transform3D cc2er)
Gets the transforms from clipping coordinates to eye coordinates
and copies them into the given Transform3Ds. | | public void | getInverseViewPlatformProjection(Canvas3D c3d, Transform3D cc2vpl, Transform3D cc2vpr)
Gets the transforms from clipping coordinates to view platform
coordinates and copies them into the given Transform3Ds. These
transforms take the clip space volume bounded by the range
[-1.0 .. | | public void | getInverseVworldProjection(Canvas3D c3d, Transform3D cc2vwl, Transform3D cc2vwr)
Gets the transforms from clipping coordinates to virtual world
coordinates and copies them into the given Transform3Ds. These
transforms take the clip space volume bounded by the range
[-1.0 .. | | public double | getPhysicalBackClipDistance(Canvas3D c3d)
Gets the back clip distance scaled to physical meters. | | public double | getPhysicalFrontClipDistance(Canvas3D c3d)
Gets the front clip distance scaled to physical meters. | | public double | getPhysicalHeight(Canvas3D c3d)
Gets the height of the specified canvas scaled to physical meters. | | public void | getPhysicalLocation(Canvas3D c3d, Point3d location)
Gets the location of the specified canvas relative to the image plate
origin. | | public double | getPhysicalToViewPlatformScale(Canvas3D c3d)
| | public double | getPhysicalToVirtualScale(Canvas3D c3d)
Gets the scale factor from physical meters to virtual units.
This method requires a Canvas3D. A different scale may be returned
across canvases for the same reasons as discussed in the description of
getPhysicalToViewPlatformScale.
The View must be attached to a ViewPlatform which is part of a live
scene graph, and the ViewPlatform node must have its
ALLOW_LOCAL_TO_VWORLD_READ capability set. | | public double | getPhysicalWidth(Canvas3D c3d)
Gets the width of the specified canvas scaled to physical meters. | | public void | getPixelLocationInImagePlate(Canvas3D c3d, int x, int y, Point3d location)
Gets the location of the AWT pixel value and copies it into the
specified Point3d. | | public void | getProjection(Canvas3D c3d, Transform3D e2ccl, Transform3D e2ccr)
Gets the transforms from eye coordinates to clipping coordinates
and copies them into the given Transform3Ds. | | public void | getSensorToVworld(Canvas3D c3d, Sensor sensor, Transform3D s2vw)
Gets a read from the specified sensor and transforms it to virtual
world coordinates. | | public void | getTrackerBaseToViewPlatform(Canvas3D c3d, Transform3D tb2vp)
Gets the transform from tracker base coordinates to view platform
coordinates and copies it into the specified Transform3D.
This method requires a Canvas3D. The returned transform may differ
across canvases for the same reasons as discussed in the description of
getViewPlatformToCoexistence. | | public void | getTrackerBaseToVworld(Canvas3D c3d, Transform3D tb2vw)
Gets the transform from tracker base coordinates to virtual world
coordinates and copies it into the specified Transform3D. | | public void | getViewPlatformToCoexistence(Canvas3D c3d, Transform3D vp2coe)
Gets the current transform from view platform coordinates to
coexistence coordinates and copies it into the given transform. View
platform coordinates are always aligned with coexistence coordinates
but may differ in scale and in Y and Z offset. | | public void | getViewPlatformToEye(Canvas3D c3d, Transform3D vp2el, Transform3D vp2er)
Gets the current transforms from view platform coordinates to eye
coordinates and copies them into the given Transform3Ds.
With a monoscopic canvas the eye transform is copied to the first
argument and the second argument is not used. | | public void | updateCanvas(Canvas3D c3d)
Arrange for an update of cached canvas parameters. | | public void | updateHead()
Arrange for an update of the cached head position if head tracking is
enabled. If automatic update has not enabled for the head position,
then this method should be called anytime a new head position is to be
read. | | public void | updateScreen(Screen3D s3d)
Arrange for an update of cached screen parameters. | | public void | updateView()
Arrange for an update of cached view parameters. If automatic update
has not been enabled for the View, then this method should be called if
any of the attributes of the View associated with this object have
changed.
These do not include the attributes of the existing Canvas3D or
Screen3D components of the View, but do include the attributes of all
other components such as the PhysicalEnvironment and PhysicalBody, and
all attributes of the attached ViewPlatform except for its
localToVworld transform. | | public void | updateViewPlatform()
Arrange for an update of the cached localToVworld
transform of the view platform. If automatic update has not been
enabled for this transform, then this method should be called anytime
the view platform has been repositioned in the virtual world and a
transform involving virtual world coordinates is desired.
The View must be attached to a ViewPlatform which is part of a live
scene graph, and the ViewPlatform node must have its
ALLOW_LOCAL_TO_VWORLD_READ capability set. | | protected boolean | useHeadTracking()
Returns true if head tracking should be used.
The default implementation returns true if the View's
getTrackingEnable method and the PhysicalEnvironment's
getTrackingAvailable method both return true.
These are the same conditions under which the Java 3D renderer uses
head tracking. |
| CANVAS_AUTO_UPDATE | | final public static int CANVAS_AUTO_UPDATE(Code) | | Indicates that updates to a Canvas3D associated with the View should
be automatically checked with each call to a public method in this
class.
|
| HEAD_AUTO_UPDATE | | final public static int HEAD_AUTO_UPDATE(Code) | | Indicates that updates to the tracked head position should be
automatically checked with each call to a public method in this class.
|
| PLATFORM_AUTO_UPDATE | | final public static int PLATFORM_AUTO_UPDATE(Code) | | Indicates that updates to the ViewPlatform localToVworld
transform should be automatically checked with each call to a public
method in this class. The View must be attached to a ViewPlatform
which is part of a live scene graph, and the ViewPlatform node must
have its ALLOW_LOCAL_TO_VWORLD_READ capability set.
|
| SCREEN_AUTO_UPDATE | | final public static int SCREEN_AUTO_UPDATE(Code) | | Indicates that updates to a Screen3D associated with the View should
be automatically checked with each call to a public method in this
class.
|
| VIEW_AUTO_UPDATE | | final public static int VIEW_AUTO_UPDATE(Code) | | Indicates that updates to the View should be automatically checked
with each call to a public method in this class.
|
| ViewInfo | | public ViewInfo(View view)(Code) | | Creates a new ViewInfo for the specified View.
Applications are responsible for informing this class of changes to the
View, its Canvas3D and Screen3D components, the tracked head position,
and the ViewPlatform's localToVworld transform. These
notifications are performed with the updateView,
updateCanvas, updateScreen,
updateHead, and updateViewPlatform
methods.
The View must be attached to a ViewPlatform. If the ViewPlatform is
attached to a live scene graph, then ALLOW_POLICY_READ
capability must be set on the ViewPlatform node.
Parameters:
view - the View to use
See Also: ViewInfo.updateView
See Also: ViewInfo.updateCanvas
See Also: updateCanvas(Canvas3D)
See Also: ViewInfo.updateScreen
See Also: updateScreen(Screen3D)
See Also: ViewInfo.updateHead
See Also: ViewInfo.updateViewPlatform |
| ViewInfo | | public ViewInfo(View view, int autoUpdateFlags)(Code) | | Creates a new ViewInfo for the specified View. The View must be
attached to a ViewPlatform. If the ViewPlatform is attached to a live
scene graph, then ALLOW_POLICY_READ capability must be set
on the ViewPlatform node.
Parameters:
view - the View to use
Parameters:
autoUpdateFlags - a logical OR of any of theVIEW_AUTO_UPDATE, CANVAS_AUTO_UPDATE,SCREEN_AUTO_UPDATE, HEAD_AUTO_UPDATE, orPLATFORM_AUTO_UPDATE flags to control whether changes tothe View, its Canvas3D or Screen3D components, the tracked headposition, or the ViewPlatform's localToVworld transformare checked automatically with each call to a public method of thisclass; if a flag is not set, then the application must inform thisclass of updates to the corresponding data
|
| ViewInfo | | public ViewInfo(View view, int autoUpdateFlags, Map screenMap, Map viewPlatformMap)(Code) | | Creates a new ViewInfo for the specified View. The View must be
attached to a ViewPlatform. If the ViewPlatform is attached to a live
scene graph, then ALLOW_POLICY_READ capability must be set
on the ViewPlatform node.
ViewInfo caches Screen3D and ViewPlatform data, but Screen3D and
ViewPlatform instances are shared across multiple Views in the Java 3D
view model. Since ViewInfo is per-View, all ViewInfo constructors
except for this one use static references to manage the shared Screen3D
and ViewPlatform objects. In this constructor, however, the caller
supplies two Map instances to hold these references for all ViewInfo
instances, so static references can be avoided; it can be used to wrap
this class into a multi-view context that provides the required
maps.
Alternatively, the other constructors can be used by calling
ViewInfo.clear when done with ViewInfo, or by simply
retaining the static references until the JVM exits.
Parameters:
view - the View to use
Parameters:
autoUpdateFlags - a logical OR of any of theVIEW_AUTO_UPDATE, CANVAS_AUTO_UPDATE,SCREEN_AUTO_UPDATE, HEAD_AUTO_UPDATE, orPLATFORM_AUTO_UPDATE flags to control whether changes tothe View, its Canvas3D or Screen3D components, the tracked headposition, or the ViewPlatform's localToVworld transformare checked automatically with each call to a public method of thisclass; if a flag is not set, then the application must inform thisclass of updates to the corresponding data
Parameters:
screenMap - a writeable Map to hold Screen3D information
Parameters:
viewPlatformMap - a writeable Map to hold ViewPlatform information
|
| clear | | public static synchronized void clear()(Code) | | Release all static memory references held by ViewInfo, if any. These
are the Screen3D and ViewPlatform maps shared by all existing ViewInfo
instances if they're not provided by a constructor. Releasing the
screen references effectively releases all canvas references in all
ViewInfo instances as well.
It is safe to continue using existing ViewInfo instances after calling
this method; the data in the released maps will be re-derived as
needed.
|
| getCoexistenceToImagePlate | | public void getCoexistenceToImagePlate(Canvas3D c3d, Transform3D coe2ipl, Transform3D coe2ipr)(Code) | | Gets the current transforms from coexistence coordinates to image plate
coordinates and copies them into the given Transform3Ds. The default
coexistence centering enable and window movement policies are
true and PHYSICAL_WORLD respectively, which
will center coexistence coordinates to the middle of the canvas,
aligned with the screen (image plate). A movement policy of
VIRTUAL_WORLD centers coexistence coordinates to the
middle of the screen.
If coexistence centering is turned off, then canvases and screens can
have arbitrary positions with respect to coexistence, set through the
the Screen3D trackerBaseToImagePlate transform and the
PhysicalEnvironment coexistenceToTrackerBase transform.
These are calibration constants used for multiple fixed screen displays.
For head mounted displays the transform is determined by the user head
position along with calibration parameters found in Screen3D and
PhysicalBody. (See the source code for the private method
getEyesHMD for more information).
With a monoscopic canvas the image plate transform is copied to the
first argument and the second argument is not used. For a stereo
canvas the first argument receives the left image plate transform, and
if the second argument is non-null it receives the right image plate
transform. These transforms are always the same unless a head mounted
display driven by a single stereo canvas is in use.
Parameters:
c3d - the Canvas3D associated with the image plate
Parameters:
coe2ipl - the Transform3D to receive the left transform
Parameters:
coe2ipr - the Transform3D to receive the right transform, or null |
| getCoexistenceToViewPlatform | | public void getCoexistenceToViewPlatform(Canvas3D c3d, Transform3D coe2vp)(Code) | | Gets the current transform from coexistence coordinates to
view platform coordinates and copies it into the given transform.
This method requires a Canvas3D. The returned transform may differ
across canvases for the same reasons as discussed in the description of
getViewPlatformToCoexistence.
Parameters:
c3d - the Canvas3D to use
Parameters:
coe2vp - the Transform3D to receive the transform
See Also: ViewInfo.getViewPlatformToCoexistence
See Also: getViewPlatformToCoexistence(Canvas3D, Transform3D) |
| getCoexistenceToVworld | | public void getCoexistenceToVworld(Canvas3D c3d, Transform3D coe2vw)(Code) | | Gets the current transform from coexistence coordinates to virtual
world coordinates and copies it into the given transform.
The View must be attached to a ViewPlatform which is part of a live
scene graph, and the ViewPlatform node must have its
ALLOW_LOCAL_TO_VWORLD_READ capability set.
This method requires a Canvas3D. The returned transform may differ
across canvases for the same reasons as discussed in the description of
getViewPlatformToCoexistence.
Parameters:
c3d - the Canvas3D to use
Parameters:
coe2vw - the Transform3D to receive the transform
See Also: ViewInfo.getViewPlatformToCoexistence
See Also: getViewPlatformToCoexistence(Canvas3D, Transform3D) |
| getEyeToImagePlate | | public void getEyeToImagePlate(Canvas3D c3d, Transform3D e2ipl, Transform3D e2ipr)(Code) | | Gets the transforms from eye coordinates to image plate coordinates and
copies them into the Transform3Ds specified.
When head tracking is used the eye positions are taken from the head
position and set in relation to the image plates with each Screen3D's
trackerBaseToImagePlate transform. Otherwise the window
eyepoint policy is used to derive the eyepoint relative to the image
plate. When using a head mounted display the eye position is
determined solely by calibration constants in Screen3D and
PhysicalBody; see the source code for the private method
getEyesHMD for more information.
Eye coordinates are always aligned with image plate coordinates, so
these transforms are always just translations. With a monoscopic
canvas the eye transform is copied to the first argument and the second
argument is not used. For a stereo canvas the first argument receives
the left eye transform, and if the second argument is non-null it
receives the right eye transform.
Parameters:
c3d - the Canvas3D associated with the image plate
Parameters:
e2ipl - the Transform3D to receive left transform
Parameters:
e2ipr - the Transform3D to receive right transform, or null |
| getEyeToViewPlatform | | public void getEyeToViewPlatform(Canvas3D c3d, Transform3D e2vpl, Transform3D e2vpr)(Code) | | Gets the current transforms from eye coordinates to view platform
coordinates and copies them into the given Transform3Ds.
With a monoscopic canvas the eye transform is copied to the first
argument and the second argument is not used. For a stereo canvas the
first argument receives the left eye transform, and if the second
argument is non-null it receives the right eye transform.
This method requires a Canvas3D. When using a head mounted display,
head tracking with fixed screens, or a window eyepoint policy of
RELATIVE_TO_COEXISTENCE, then the transforms returned may
be different for each canvas if stereo is not in use and they have
different monoscopic view policies. They may additionally differ in
scale across canvases with the PHYSICAL_WORLD window
resize policy or the SCALE_SCREEN_SIZE screen scale
policy, which alter the scale depending upon the width of the canvas or
the width of the screen respectively.
With window eyepoint policies of RELATIVE_TO_FIELD_OF_VIEW,
RELATIVE_TO_SCREEN, or RELATIVE_TO_WINDOW,
then the transforms returned may differ across canvases due to
the following additional conditions:
- The window eyepoint policy is
RELATIVE_TO_WINDOW or
RELATIVE_TO_SCREEN, in which case the manual eye
position in image plate can be set differently for each
canvas.
- The window eyepoint policy is
RELATIVE_TO_FIELD_OF_VIEW
and the view attach policy is NOMINAL_SCREEN, which
decouples the view platform's canvas Z offset from the eyepoint's
canvas Z offset.
- The eyepoint X and Y coordinates are centered in the canvas with a
window eyepoint policy of
RELATIVE_TO_FIELD_OF_VIEW
or RELATIVE_TO_WINDOW, and a window movement policy
of VIRTUAL_WORLD centers the view platform's X and Y
coordinates to the middle of the screen.
- Coexistence centering is set false, which allows each canvas and
screen to have a different position with respect to coexistence
coordinates.
Parameters:
c3d - the Canvas3D to use
Parameters:
e2vpl - the Transform3D to receive the left transform
Parameters:
e2vpr - the Transform3D to receive the right transform, or null |
| getEyeToVworld | | public void getEyeToVworld(Canvas3D c3d, Transform3D e2vwl, Transform3D e2vwr)(Code) | | Gets the current transforms from eye coordinates to virtual world
coordinates and copies them into the given Transform3Ds.
With a monoscopic canvas the eye transform is copied to the first
argument and the second argument is not used. For a stereo canvas the
first argument receives the left eye transform, and if the second
argument is non-null it receives the right eye transform.
The View must be attached to a ViewPlatform which is part of a live
scene graph, and the ViewPlatform node must have its
ALLOW_LOCAL_TO_VWORLD_READ capability set.
This method requires a Canvas3D. The transforms returned may differ
across canvases for all the same reasons discussed in the description
of getEyeToViewPlatform.
Parameters:
c3d - the Canvas3D to use
Parameters:
e2vwl - the Transform3D to receive the left transform
Parameters:
e2vwr - the Transform3D to receive the right transform, or null
See Also: ViewInfo.getEyeToViewPlatform
See Also: getEyeToViewPlatform(Canvas3D, Transform3D, Transform3D) |
| getHeadTrackerToTrackerBase | | protected Transform3D getHeadTrackerToTrackerBase()(Code) | | Returns a reference to a Transform3D containing the current transform
from head tracker coordinates to tracker base coordinates. It is only
called if useHeadTracking returns true and a head position
update is specified with updateHead or the
HEAD_AUTO_UPDATE constructor flag.
The default implementation uses the head tracking sensor specified by
the View's PhysicalEnvironment, and reads it by calling the sensor's
getRead method directly. The result is a sensor reading
that may have been taken at a slightly different time from the one used
by the renderer. This method can be overridden to synchronize the two
readings through an external mechanism.
current head tracker to tracker base transform
See Also: ViewInfo.useHeadTracking
See Also: ViewInfo.updateHead
See Also: ViewInfo.HEAD_AUTO_UPDATE |
| getImagePlateToViewPlatform | | public void getImagePlateToViewPlatform(Canvas3D c3d, Transform3D ip2vpl, Transform3D ip2vpr)(Code) | | Gets the current transforms from image plate coordinates to view
platform coordinates and copies them into the given Transform3Ds.
With a monoscopic canvas the image plate transform is copied to the
first argument and the second argument is not used. For a stereo
canvas the first argument receives the left image plate transform, and
if the second argument is non-null it receives the right image plate
transform. These transforms are always the same unless a head mounted
display driven by a single stereo canvas is in use.
Parameters:
c3d - the Canvas3D associated with the image plate
Parameters:
ip2vpl - the Transform3D to receive the left transform
Parameters:
ip2vpr - the Transform3D to receive the right transform, or null |
| getImagePlateToVworld | | public void getImagePlateToVworld(Canvas3D c3d, Transform3D ip2vwl, Transform3D ip2vwr)(Code) | | Gets the current transforms from image plate coordinates to virtual
world coordinates and copies them into the given Transform3Ds.
With a monoscopic canvas the image plate transform is copied to the
first argument and the second argument is not used. For a stereo
canvas the first argument receives the left image plate transform, and
if the second argument is non-null it receives the right image plate
transform. These transforms are always the same unless a head mounted
display driven by a single stereo canvas is in use.
The View must be attached to a ViewPlatform which is part of a live
scene graph, and the ViewPlatform node must have its
ALLOW_LOCAL_TO_VWORLD_READ capability set.
Parameters:
c3d - the Canvas3D associated with the image plate
Parameters:
ip2vwl - the Transform3D to receive the left transform
Parameters:
ip2vwr - the Transform3D to receive the right transform, or null |
| getInverseProjection | | public void getInverseProjection(Canvas3D c3d, Transform3D cc2el, Transform3D cc2er)(Code) | | Gets the transforms from clipping coordinates to eye coordinates
and copies them into the given Transform3Ds. These transforms take
the clip space volume bounded by the range [-1.0 .. + 1.0] on each
of the X, Y, and Z and project it into eye coordinates.
With a monoscopic canvas the projection transform is copied to the
first argument and the second argument is not used. For a stereo
canvas the first argument receives the left projection transform, and
if the second argument is non-null it receives the right projection
transform.
If either of the clip policies VIRTUAL_EYE or
VIRTUAL_SCREEN are used, then the View should be attached
to a ViewPlatform that is part of a live scene graph and that has its
ALLOW_LOCAL_TO_VWORLD_READ capability set; otherwise, a
scale factor of 1.0 will be used for the scale factor from virtual
world units to view platform units.
Parameters:
c3d - the Canvas3D to use
Parameters:
cc2el - the Transform3D to receive left transform
Parameters:
cc2er - the Transform3D to receive right transform, or null |
| getInverseViewPlatformProjection | | public void getInverseViewPlatformProjection(Canvas3D c3d, Transform3D cc2vpl, Transform3D cc2vpr)(Code) | | Gets the transforms from clipping coordinates to view platform
coordinates and copies them into the given Transform3Ds. These
transforms take the clip space volume bounded by the range
[-1.0 .. +1.0] on each of the X, Y, and Z axes and project into
the view platform coordinate system.
With a monoscopic canvas the projection transform is copied to the
first argument and the second argument is not used. For a stereo
canvas the first argument receives the left projection transform, and
if the second argument is non-null it receives the right projection
transform.
If either of the clip policies VIRTUAL_EYE or
VIRTUAL_SCREEN are used, then the View should be attached
to a ViewPlatform that is part of a live scene graph and that has its
ALLOW_LOCAL_TO_VWORLD_READ capability set; otherwise, a
scale factor of 1.0 will be used for the scale factor from virtual
world units to view platform units.
Parameters:
c3d - the Canvas3D to use
Parameters:
cc2vpl - the Transform3D to receive left transform
Parameters:
cc2vpr - the Transform3D to receive right transform, or null |
| getInverseVworldProjection | | public void getInverseVworldProjection(Canvas3D c3d, Transform3D cc2vwl, Transform3D cc2vwr)(Code) | | Gets the transforms from clipping coordinates to virtual world
coordinates and copies them into the given Transform3Ds. These
transforms take the clip space volume bounded by the range
[-1.0 .. +1.0] on each of the X, Y, and Z axes and project into
the virtual world.
With a monoscopic canvas the projection transform is copied to the
first argument and the second argument is not used. For a stereo
canvas the first argument receives the left projection transform, and
if the second argument is non-null it receives the right projection
transform.
The View must be attached to a ViewPlatform which is part of a live
scene graph, and the ViewPlatform node must have its
ALLOW_LOCAL_TO_VWORLD_READ capability set.
Parameters:
c3d - the Canvas3D to use
Parameters:
cc2vwl - the Transform3D to receive left transform
Parameters:
cc2vwr - the Transform3D to receive right transform, or null |
| getPhysicalBackClipDistance | | public double getPhysicalBackClipDistance(Canvas3D c3d)(Code) | | Gets the back clip distance scaled to physical meters. This is useful
for ensuring that objects positioned relative to a physical coordinate
system (such as eye, image plate, or coexistence) will be within the
viewable Z depth. This distance will be relative to either the eye or
the image plate depending upon the back clip policy.
Note that this is not necessarily the clip distance as set by
setBackClipDistance, even when the back clip policy
is PHYSICAL_SCREEN or PHYSICAL_EYE. If
the window resize policy is PHYSICAL_WORLD, then physical
clip distances as specified are in fact scaled by the ratio of the
window width to the screen width. The Java 3D view model does this
to prevent the physical clip planes from moving with respect to the
virtual world when the window is resized.
If either of the clip policies VIRTUAL_EYE or
VIRTUAL_SCREEN are used, then the View should be attached
to a ViewPlatform that is part of a live scene graph and that has its
ALLOW_LOCAL_TO_VWORLD_READ capability set; otherwise, a
scale factor of 1.0 will be used for the scale factor from virtual
world units to view platform units.
Parameters:
c3d - the Canvas3D to use the physical back clip distance |
| getPhysicalFrontClipDistance | | public double getPhysicalFrontClipDistance(Canvas3D c3d)(Code) | | Gets the front clip distance scaled to physical meters. This is useful
for ensuring that objects positioned relative to a physical coordinate
system (such as eye, image plate, or coexistence) will be within the
viewable Z depth. This distance will be relative to either the eye or
the image plate depending upon the front clip policy.
Note that this is not necessarily the clip distance as set by
setFrontClipDistance, even when the front clip policy
is PHYSICAL_SCREEN or PHYSICAL_EYE. If
the window resize policy is PHYSICAL_WORLD, then physical
clip distances as specified are in fact scaled by the ratio of the
window width to the screen width. The Java 3D view model does this
to prevent the physical clip planes from moving with respect to the
virtual world when the window is resized.
If either of the clip policies VIRTUAL_EYE or
VIRTUAL_SCREEN are used, then the View should be attached
to a ViewPlatform that is part of a live scene graph and that has its
ALLOW_LOCAL_TO_VWORLD_READ capability set; otherwise, a
scale factor of 1.0 will be used for the scale factor from virtual
world units to view platform units.
Parameters:
c3d - the Canvas3D to use the physical front clip distance |
| getPhysicalHeight | | public double getPhysicalHeight(Canvas3D c3d)(Code) | | Gets the height of the specified canvas scaled to physical meters. This
is derived from the physical screen height as reported by the Screen3D
associated with the canvas. If the screen height is not explicitly set
using the setPhysicalScreenHeight method of Screen3D, then
Java 3D will derive the screen height based on a screen resolution of 90
pixels/inch.
Parameters:
c3d - the Canvas3D to use the height of the canvas scaled to physical meters |
| getPhysicalLocation | | public void getPhysicalLocation(Canvas3D c3d, Point3d location)(Code) | | Gets the location of the specified canvas relative to the image plate
origin. This is derived from the physical screen parameters as
reported by the Screen3D associated with the canvas. If the screen
width and height are not explicitly set in Screen3D, then Java 3D will
derive those screen parameters based on a screen resolution of 90
pixels/inch.
Parameters:
c3d - the Canvas3D to use
Parameters:
location - the output position, in meters, of the lower-leftcorner of the canvas relative to the image plate lower-left corner; Zis always 0.0 |
| getPhysicalToViewPlatformScale | | public double getPhysicalToViewPlatformScale(Canvas3D c3d)(Code) | | Gets the scale factor from physical meters to view platform units.
This method requires a Canvas3D. A different scale may be returned
for each canvas in the view if any of the following apply:
- The window resize policy is
PHYSICAL_WORLD, which
alters the scale depending upon the width of the canvas.
- The screen scale policy is
SCALE_SCREEN_SIZE,
which alters the scale depending upon the width of the screen
associated with the canvas.
Parameters:
c3d - the Canvas3D to use the physical to view platform scale |
| getPhysicalToVirtualScale | | public double getPhysicalToVirtualScale(Canvas3D c3d)(Code) | | Gets the scale factor from physical meters to virtual units.
This method requires a Canvas3D. A different scale may be returned
across canvases for the same reasons as discussed in the description of
getPhysicalToViewPlatformScale.
The View must be attached to a ViewPlatform which is part of a live
scene graph, and the ViewPlatform node must have its
ALLOW_LOCAL_TO_VWORLD_READ capability set.
Parameters:
c3d - the Canvas3D to use the physical to virtual scale
See Also: ViewInfo.getPhysicalToViewPlatformScale
See Also: getPhysicalToViewPlatformScale(Canvas3D) |
| getPhysicalWidth | | public double getPhysicalWidth(Canvas3D c3d)(Code) | | Gets the width of the specified canvas scaled to physical meters. This
is derived from the physical screen width as reported by the Screen3D
associated with the canvas. If the screen width is not explicitly set
using the setPhysicalScreenWidth method of Screen3D, then
Java 3D will derive the screen width based on a screen resolution of 90
pixels/inch.
Parameters:
c3d - the Canvas3D to use the width of the canvas scaled to physical meters |
| getPixelLocationInImagePlate | | public void getPixelLocationInImagePlate(Canvas3D c3d, int x, int y, Point3d location)(Code) | | Gets the location of the AWT pixel value and copies it into the
specified Point3d.
Parameters:
c3d - the Canvas3D to use
Parameters:
x - the X coordinate of the pixel relative to the upper-leftcorner of the canvas
Parameters:
y - the Y coordinate of the pixel relative to the upper-leftcorner of the canvas
Parameters:
location - the output position, in meters, relative to thelower-left corner of the image plate; Z is always 0.0 |
| getProjection | | public void getProjection(Canvas3D c3d, Transform3D e2ccl, Transform3D e2ccr)(Code) | | Gets the transforms from eye coordinates to clipping coordinates
and copies them into the given Transform3Ds. These transforms take
a viewing volume bounded by the physical canvas edges and the
physical front and back clip planes and project it into a range
bound to [-1.0 .. +1.0] on each of the X, Y, and Z axes. If a
perspective projection has been specified then the physical image
plate eye location defines the apex of a viewing frustum;
otherwise, the orientation of the image plate determines the
direction of a parallel projection.
With a monoscopic canvas the projection transform is copied to the
first argument and the second argument is not used. For a stereo
canvas the first argument receives the left projection transform,
and if the second argument is non-null it receives the right
projection transform.
If either of the clip policies VIRTUAL_EYE or
VIRTUAL_SCREEN are used, then the View should be attached
to a ViewPlatform that is part of a live scene graph and that has its
ALLOW_LOCAL_TO_VWORLD_READ capability set; otherwise, a
scale factor of 1.0 will be used for the scale factor from virtual
world units to view platform units.
Parameters:
c3d - the Canvas3D to use
Parameters:
e2ccl - the Transform3D to receive left transform
Parameters:
e2ccr - the Transform3D to receive right transform, or null |
| getSensorToVworld | | public void getSensorToVworld(Canvas3D c3d, Sensor sensor, Transform3D s2vw)(Code) | | Gets a read from the specified sensor and transforms it to virtual
world coordinates. The View must be attached to a ViewPlatform which
is part of a live scene graph, and the ViewPlatform node must have its
ALLOW_LOCAL_TO_VWORLD_READ capability set.
This method requires a Canvas3D. The returned transform may differ
across canvases for the same reasons as discussed in the description of
getViewPlatformToCoexistence.
Parameters:
sensor - the Sensor instance to read
Parameters:
s2vw - the output transform
See Also: ViewInfo.getViewPlatformToCoexistence
See Also: getViewPlatformToCoexistence(Canvas3D, Transform3D) |
| getTrackerBaseToViewPlatform | | public void getTrackerBaseToViewPlatform(Canvas3D c3d, Transform3D tb2vp)(Code) | | Gets the transform from tracker base coordinates to view platform
coordinates and copies it into the specified Transform3D.
This method requires a Canvas3D. The returned transform may differ
across canvases for the same reasons as discussed in the description of
getViewPlatformToCoexistence.
Parameters:
c3d - the Canvas3D to use
Parameters:
tb2vp - the output transform
See Also: ViewInfo.getViewPlatformToCoexistence
See Also: getViewPlatformToCoexistence(Canvas3D, Transform3D) |
| getTrackerBaseToVworld | | public void getTrackerBaseToVworld(Canvas3D c3d, Transform3D tb2vw)(Code) | | Gets the transform from tracker base coordinates to virtual world
coordinates and copies it into the specified Transform3D. The View
must be attached to a ViewPlatform which is part of a live scene graph,
and the ViewPlatform node must have its
ALLOW_LOCAL_TO_VWORLD_READ capability set.
This method requires a Canvas3D. The returned transform may differ
across canvases for the same reasons as discussed in the description of
getViewPlatformToCoexistence.
Parameters:
c3d - the Canvas3D to use
Parameters:
tb2vw - the output transform
See Also: ViewInfo.getViewPlatformToCoexistence
See Also: getViewPlatformToCoexistence(Canvas3D, Transform3D) |
| getViewPlatformToCoexistence | | public void getViewPlatformToCoexistence(Canvas3D c3d, Transform3D vp2coe)(Code) | | Gets the current transform from view platform coordinates to
coexistence coordinates and copies it into the given transform. View
platform coordinates are always aligned with coexistence coordinates
but may differ in scale and in Y and Z offset. The scale is derived
from the window resize and screen scale policies, while the offset is
derived from the view attach policy.
Java 3D constructs a view from the physical position of the eyes
relative to the physical positions of the image plates; it then uses a
view platform to position that physical configuration into the virtual
world and from there computes the correct projections of the virtual
world onto the physical image plates. Coexistence coordinates are used
to place the physical positions of the view platform, eyes, head, image
plate, sensors, and tracker base in relation to each other. The view
platform is positioned with respect to the virtual world through the
scene graph, so the view platform to coexistence transform defines the
space in which the virtual world and physical world coexist.
This method requires a Canvas3D. A different transform may be returned
for each canvas in the view if any of the following apply:
- The window resize policy is
PHYSICAL_WORLD, which
alters the scale depending upon the width of the canvas.
- The screen scale policy is
SCALE_SCREEN_SIZE,
which alters the scale depending upon the width of the screen
associated with the canvas.
- A window eyepoint policy of
RELATIVE_TO_FIELD_OF_VIEW
with a view attach policy of NOMINAL_HEAD in effect,
which sets the view platform Z offset in coexistence coordinates
based on the width of the canvas. These are the default policies.
The offset also follows the width of the canvas when the
NOMINAL_FEET view attach policy is used.
Parameters:
c3d - the Canvas3D to use
Parameters:
vp2coe - the Transform3D to receive the transform |
| getViewPlatformToEye | | public void getViewPlatformToEye(Canvas3D c3d, Transform3D vp2el, Transform3D vp2er)(Code) | | Gets the current transforms from view platform coordinates to eye
coordinates and copies them into the given Transform3Ds.
With a monoscopic canvas the eye transform is copied to the first
argument and the second argument is not used. For a stereo canvas the
first argument receives the left eye transform, and if the second
argument is non-null it receives the right eye transform.
This method requires a Canvas3D. The transforms returned may differ
across canvases for all the same reasons discussed in the description
of getEyeToViewPlatform.
Parameters:
c3d - the Canvas3D to use
Parameters:
vp2el - the Transform3D to receive the left transform
Parameters:
vp2er - the Transform3D to receive the right transform, or null
See Also: ViewInfo.getEyeToViewPlatform
See Also: getEyeToViewPlatform(Canvas3D, Transform3D, Transform3D) |
| updateCanvas | | public void updateCanvas(Canvas3D c3d)(Code) | | Arrange for an update of cached canvas parameters. If automatic update
has not been enabled, then this method should be called if any of the
attributes of the Canvas3D have changed. These attributes include the
canvas position and size, but do not include the attributes of
the associated Screen3D, which are cached separately.
Parameters:
c3d - the Canvas3D to update |
| updateHead | | public void updateHead()(Code) | | Arrange for an update of the cached head position if head tracking is
enabled. If automatic update has not enabled for the head position,
then this method should be called anytime a new head position is to be
read.
|
| updateScreen | | public void updateScreen(Screen3D s3d)(Code) | | Arrange for an update of cached screen parameters. If automatic update
has not been enabled, then this method should be called if any of the
attributes of the Screen3D have changed. This method should also be
called if the screen changes pixel resolution.
Parameters:
s3d - the Screen3D to update |
| updateView | | public void updateView()(Code) | | Arrange for an update of cached view parameters. If automatic update
has not been enabled for the View, then this method should be called if
any of the attributes of the View associated with this object have
changed.
These do not include the attributes of the existing Canvas3D or
Screen3D components of the View, but do include the attributes of all
other components such as the PhysicalEnvironment and PhysicalBody, and
all attributes of the attached ViewPlatform except for its
localToVworld transform. The screen and canvas components
as well as the ViewPlatform's localToVworld are cached
separately.
This method should also be called if the ViewPlatform is replaced with
another using the View's attachViewPlatform method, or if
any of the setCanvas3D, addCanvas3D,
insertCanvas3D, removeCanvas3D, or
removeAllCanvas3Ds methods of View are called to change
the View's canvas list.
Calling this method causes most transforms to be re-derived. It should
be used only when necessary.
|
| updateViewPlatform | | public void updateViewPlatform()(Code) | | Arrange for an update of the cached localToVworld
transform of the view platform. If automatic update has not been
enabled for this transform, then this method should be called anytime
the view platform has been repositioned in the virtual world and a
transform involving virtual world coordinates is desired.
The View must be attached to a ViewPlatform which is part of a live
scene graph, and the ViewPlatform node must have its
ALLOW_LOCAL_TO_VWORLD_READ capability set.
|
| useHeadTracking | | protected boolean useHeadTracking()(Code) | | Returns true if head tracking should be used.
The default implementation returns true if the View's
getTrackingEnable method and the PhysicalEnvironment's
getTrackingAvailable method both return true.
These are the same conditions under which the Java 3D renderer uses
head tracking. This method can be overridden if there is any need to
decouple the head tracking status of ViewInfo from the renderer.
true if ViewInfo should use head tracking |
|
|