All Packages  Class Hierarchy  This Package  Previous  Next  Index

Class java.media.j3d.View

java.lang.Object
   |
   +----java.media.j3d.View

public class View

extends Object

HMD_VIEW

Specifies that Java 3D should compute new viewpoints using that sequence of transforms appropriate to head-mounted display environments.

NOMINAL_FEET

Specifies that Java 3D should locate the user's virtual head at whatever vertical position is needed to ensure that the user's virtual feet touch the virtual ground plane (as determined by the current head position).

NOMINAL_HEAD

Specifies that Java 3D should locate the user's virtual head at the same point as the user's physical head (as determined by the current head position).

NOMINAL_SCREEN

Specifies that Java 3D should locate the user's virtual head at a point offset by nominalEyeDistanceFromNominalScreen from the user's physical head (as determined by the current head position).

PARALLEL_PROJECTION

Specifies that Java 3D should generate a parallel projection matrix for this View.

PERSPECTIVE_PROJECTION

Specifies that Java 3D should generate a perspective projection matrix for this View.

PHYSICAL_EYE

Specifies that the associated distance is measured from the eye and in the physical environment.

PHYSICAL_SCREEN

Specifies that the associated distance is measured from the screen and in the physical environment.

SCREEN_VIEW

Specifies that Java 3D should compute new viewpoints using that sequence of transforms appropriate to screen-based head-tracked display environments (fish-tank VR/portals/VR-desks).

VIRTUAL_EYE

Specifies that the associated distance is measured from the eye and in the virtual environment.

VIRTUAL_SCREEN

Specifies that the associated distance is measured from the screen and in the virtual environment.

View()

Constructs and initializes a View object.

addCanvas3D(Canvas3D)

Adds the given canvas3D at the end of the list.

attachViewPlatform(ViewPlatform)

Attach viewPlatform structure to this view.

getAllCanvas3Ds()

Gets the enumeration object of all the canvas3Ds.

getBackClipDistance()

Returns the view model's back clip distance.

getBackClipPolicy()

Returns the view model's current back clip policy.

getCanvas3D(int)

Gets the canvas3D from the given index position.

getCompatibilityModeEnable()

Retrieves the compatibility mode enable flag.

getCurrentFrameStartTime()

This method returns the time at which the most recent rendering frame started.

getDepthBufferFreezeTransparent()

Retrieves the current value of the depth buffer freeze transparent flag for this view.

getFieldOfView()

Returns the current field of view.

getFrontClipDistance()

Returns the view model's front clip distance.

getFrontClipPolicy()

Returns the view model's current front clip policy.

getLastFrameDuration()

This method returns the duration, in milliseconds, of the most recently completed rendering frame.

getLeftProjection(Transform3D)

Retrieves the current projection transform for the left eye and places it into the specified object.

getLocalEyeLightingEnable()

Retrieves a flag that indicates whether or not local eye lighting is enabled for this view.

getPhysicalBody()

Returns a reference to the view model's PhysicalBody object.

getPhysicalEnvironment()

Returns a reference to the view model's PhysicalEnvironment object.

getProjectionPolicy()

Retrieves the current projection policy for this View.

getRightProjection(Transform3D)

Retrieves the current projection transform for the right eye and places it into the specified object.

getSceneAntialiasingEnable()

Returns a flag that indicates whether or not scene antialiasing is enabled for this view.

getSensorHotspotInVworld(Sensor, Point3d)

Retrieves the position of the specified Sensor's last known hotspot position in virtual-world coordinates and copies that value into the vector provided.

getSensorHotspotInVworld(Sensor, Point3f)

Retrieves the position of the specified Sensor's last known hotspot position in virtual-world coordinates and copies that value into the vector provided.

getSensorToVworld(Sensor, Transform3D)

Computes the sensor to virtual-world transform and copies that value into the transform provided.

getTrackingEnable()

Returns a status flag indicating whether or not tracking is enabled.

getUserHeadToTrackerBase(Transform3D)

Retrieves the user-head to the head-tracker-base transform and copies that value into the specified Transform3D object.

getUserHeadToVworld(Transform3D)

Retrieves the user-head to virtual-world transform and copies that value into the transform provided.

getUserHeadToVworldEnable()

Returns a status flag indicating whether or not Java 3D is continuously updating the userHeadToVworldEnable transform.

getViewPolicy()

Retrieves the current view computation policy for this View.

getVpcToEc(Transform3D)

Retrieves the current ViewPlatform Coordinates (VPC) system to Eye Coordinates (EC) transform and copies it into the specified object.

insertCanvas3D(Canvas3D, int)

Inserts the canvas3D at the given index position.

removeCanvas3D(Canvas3D)

Removes the given canvas3D.

removeCanvas3D(int)

Removes the canvas3D from the given index position.

setBackClipDistance(double)

Sets the view model's back clip distance.

setBackClipPolicy(int)

Sets the view model's back clip policy, the policy Java 3D uses in computing where to place the back clip plane.

setCanvas3D(Canvas3D, int)

Sets given canvas3D at the given index position.

setCompatibilityModeEnable(boolean)

Sets the compatibility mode enable flag to true or false.

setDepthBufferFreezeTransparent(boolean)

Enables or disables automatic freezing of the depth buffer for objects rendered during the transparent rendering pass (i.e., objects rendered using alpha blending) for this view.

setFieldOfView(double)

Sets the field of view used to compute the projection transform.

setFrontClipDistance(double)

Sets the view model's front clip distance.

setFrontClipPolicy(int)

Sets the view model's front clip policy, the policy Java 3D uses in computing where to place the front clip plane.

setLeftProjection(Transform3D)

Compatibility mode function that specifies a viewing frustum for the left eye that transforms points in Eye Coordinates (EC) to Clipping Coordinates (CC).

setLocalEyeLightingEnable(boolean)

Sets a flag that indicates whether the local eye point is used in lighting calculations for perspective projections.

setPhysicalBody(PhysicalBody)

Sets the view model's physical body to the PhysicalBody object provided.

setPhysicalEnvironment(PhysicalEnvironment)

Sets the view model's physical environment to the PhysicalEnvironment object provided.

setProjectionPolicy(int)

Sets the projection policy for this View.

setRightProjection(Transform3D)

Compatibility mode function that specifies a viewing frustum for the right eye that transforms points in Eye Coordinates (EC) to Clipping Coordinates (CC).

setSceneAntialiasingEnable(boolean)

Enables or disables scene antialiasing for this view.

setTrackingEnable(boolean)

Turns tracking on or off.

setUserHeadToVworldEnable(boolean)

Turns on or off the continuous updating of the userHeadToVworld transform.

setViewPolicy(int)

Sets the policy for view computation.

setVpcToEc(Transform3D)

Compatibility mode method that specifies the ViewPlatform Coordinates (VPC) to Eye Coordinates (EC) transform.

 public static final int NOMINAL_HEAD

Specifies that Java 3D should locate the user's virtual head at the same point as the user's physical head (as determined by the current head position). One of three policies (NOMINAL_HEAD, NOMINAL_SCREEN, and NOMINAL_FEET) for determining eye position as a function of current head position.

 public static final int NOMINAL_SCREEN

Specifies that Java 3D should locate the user's virtual head at a point offset by nominalEyeDistanceFromNominalScreen from the user's physical head (as determined by the current head position). This offset, in effect, creates a viewpoint where the user sees an object from an optimal viewpoint. One of three policies (NOMINAL_HEAD, NOMINAL_SCREEN, and NOMINAL_FEET) for determining eye position as a function of current head position.

 public static final int NOMINAL_FEET

Specifies that Java 3D should locate the user's virtual head at whatever vertical position is needed to ensure that the user's virtual feet touch the virtual ground plane (as determined by the current head position). One of three policies (NOMINAL_HEAD, NOMINAL_SCREEN, and NOMINAL_FEET) for determining eye position as a function of current head position.

 public static final int PHYSICAL_EYE

Specifies that the associated distance is measured from the eye and in the physical environment. Policy for interpreting clip plane distances. Used in specifying the policy in frontClipPolicy and backClipPolicy.

 public static final int PHYSICAL_SCREEN

Specifies that the associated distance is measured from the screen and in the physical environment. Policy for interpreting clip plane distances. Used in specifying the policy in frontClipPolicy and backClipPolicy.

 public static final int VIRTUAL_EYE

Specifies that the associated distance is measured from the eye and in the virtual environment. Policy for interpreting clip plane distances. Used in specifying the policy in frontClipPolicy and backClipPolicy.

 public static final int VIRTUAL_SCREEN

Specifies that the associated distance is measured from the screen and in the virtual environment. Policy for interpreting clip plane distances. Used in specifying the policy in frontClipPolicy and backClipPolicy.

 public static final int SCREEN_VIEW

Specifies that Java 3D should compute new viewpoints using that sequence of transforms appropriate to screen-based head-tracked display environments (fish-tank VR/portals/VR-desks). One of two policies for view computation: SCREEN_VIEW and HMD_VIEW.

 public static final int HMD_VIEW

Specifies that Java 3D should compute new viewpoints using that sequence of transforms appropriate to head-mounted display environments. One of two policies for view computation: SCREEN_VIEW and HMD_VIEW.

 public static final int PARALLEL_PROJECTION

Specifies that Java 3D should generate a parallel projection matrix for this View.

 public static final int PERSPECTIVE_PROJECTION

Specifies that Java 3D should generate a perspective projection matrix for this View. This is the default mode.

 public View()

Constructs and initializes a View object. Only some of the attributes are fully initialized.

Returns:

a new View

 public final void setViewPolicy(int policy)

Sets the policy for view computation. This variable specifies how Java 3D uses its transforms in computing new viewpoints.

• SCREEN_VIEW specifies that Java 3D should compute a new viewpoint using the sequence of transforms appropriate to screen-based head-tracked display environments (fish-tank VR/portals/VR-desks).
• HMD_VIEW specifies that Java 3D should compute a new viewpoint using the sequence of transforms appropriate to head mounted display environments.

Parameters:

policy - the new policy, one of SCREEN_VIEW or HMD_VIEW

 public final int getViewPolicy()

Retrieves the current view computation policy for this View.

Returns:

one of: SCREEN_VIEW or HMD_VIEW.

 public final void setProjectionPolicy(int policy)

Sets the projection policy for this View. This variable specifies the type of projection transform that will be generated. A value of PARALLEL_PROJECTION specifies that a parallel projection transform is generated. A value of PERSPECTIVE_PROJECTION specifies that a perspective projection transform is generated. The default projection policy is perspective.

Parameters:

policy - the new policy, one of PARALLEL_PROJECTION or PERSPECTIVE_PROJECTION

 public final int getProjectionPolicy()

Retrieves the current projection policy for this View.

Returns:

one of: PARALLEL_PROJECTION or PERSPECTIVE_PROJECTION.

 public final void setCompatibilityModeEnable(boolean flag)

Sets the compatibility mode enable flag to true or false. Compatibility mode is disabled by default.

Parameters:

flag - the new compatibility mode enable flag

 public final boolean getCompatibilityModeEnable()

Retrieves the compatibility mode enable flag.

Returns:

the current compatibility mode enable flag

 public final void setLeftProjection(Transform3D projection)

Compatibility mode function that specifies a viewing frustum for the left eye that transforms points in Eye Coordinates (EC) to Clipping Coordinates (CC). If compatibility mode is disabled, then the projection is derived from other values and is read-only. In monoscopic mode, only the left eye projection matrix is used.

Parameters:

projection - the new left eye projection transform

Throws: RestrictedAccessException

if compatibility mode is disabled.

 public final void setRightProjection(Transform3D projection)

Compatibility mode function that specifies a viewing frustum for the right eye that transforms points in Eye Coordinates (EC) to Clipping Coordinates (CC). If compatibility mode is disabled, then the projection is derived from other values and is read-only. In monoscopic mode, the right eye projection matrix is ignored.

Parameters:

projection - the new right eye projection transform

Throws: RestrictedAccessException

if compatibility mode is disabled.

 public final void getLeftProjection(Transform3D projection)

Retrieves the current projection transform for the left eye and places it into the specified object.

Parameters:

projection - the Transform3D object that will receive the projection

 public final void getRightProjection(Transform3D projection)

Retrieves the current projection transform for the right eye and places it into the specified object.

Parameters:

projection - the Transform3D object that will receive the projection

 public final void setVpcToEc(Transform3D vpcToEc)

Compatibility mode method that specifies the ViewPlatform Coordinates (VPC) to Eye Coordinates (EC) transform. If compatibility mode is disabled, then this transform is derived from other values and is read-only.

Parameters:

vpcToEc - the new VPC to EC transform

Throws: RestrictedAccessException

if compatibility mode is disabled.

 public final void getVpcToEc(Transform3D vpcToEc)

Retrieves the current ViewPlatform Coordinates (VPC) system to Eye Coordinates (EC) transform and copies it into the specified object.

Parameters:

vpcToEc - the object that will receive the vpcToEc transform.

 public final void setPhysicalBody(PhysicalBody physicalBody)

Sets the view model's physical body to the PhysicalBody object provided. Java 3D uses the parameters in the PhysicalBody to ensure accurate image and sound generation when in head-tracked mode.

Parameters:

physicalBody - the new PhysicalBody object

 public final PhysicalBody getPhysicalBody()

Returns a reference to the view model's PhysicalBody object.

Returns:

the view object's PhysicalBody object

 public final void setPhysicalEnvironment(PhysicalEnvironment physicalEnvironment)

Sets the view model's physical environment to the PhysicalEnvironment object provided.

Parameters:

physicalEnvironment - the new PhysicalEnvironment object

 public final PhysicalEnvironment getPhysicalEnvironment()

Returns a reference to the view model's PhysicalEnvironment object.

Returns:

the view object's PhysicalEnvironment object

 public final void setFieldOfView(double fieldOfView)

Sets the field of view used to compute the projection transform. This is used when head tracking is disabled and when the Canvas3D's windowEyepointPolicy is RELATIVE_TO_FIELD_OF_VIEW.

Parameters:

fieldOfView - the new field of view

 public final double getFieldOfView()

Returns the current field of view.

Returns:

the current field of view

 public final void setFrontClipDistance(double distance)

Sets the view model's front clip distance. This value specifies the distance away from the clip origin in the direction of gaze where objects stop disappearing. Objects closer than the clip origin offset by the front clip distance are not drawn.

Parameters:

distance - the new front clip distance

See Also:

setBackDistance

 public final double getFrontClipDistance()

Returns the view model's front clip distance.

Returns:

the current front clip distance

 public final void setBackClipDistance(double distance)

Sets the view model's back clip distance. The parameter specifies the distance from the clip origin in the direction of gaze to where objects begin disappearing. Objects farther away than the clip-origin offset by the back-clip-distance are not drawn.

Note that this attribute is only used if there is no Clip node that is in scope of the view platform associated with this view.

Parameters:

distance - the new back clip distance

See Also:

setBackDistance

 public final double getBackClipDistance()

Returns the view model's back clip distance.

Returns:

the current back clip distance

 public final void getUserHeadToVworld(Transform3D t)

Retrieves the user-head to virtual-world transform and copies that value into the transform provided.

Parameters:

t - the Transform3D object that will receive the transform

 public final void getUserHeadToTrackerBase(Transform3D t)

Retrieves the user-head to the head-tracker-base transform and copies that value into the specified Transform3D object. If a head tracker is not present, this matrix is not updated. If a head tracker is present, the system updates this matrix with information about the user's current head position and orientation.

Parameters:

t - the object that will receive the transform

 public final void setFrontClipPolicy(int policy)

Sets the view model's front clip policy, the policy Java 3D uses in computing where to place the front clip plane. The variable can contain one of:

• PHYSICAL_EYE, to specify that the associated distance is from the eye and in units of physical distance
• PHYSICAL_SCREEN, to specify that the associated distance is from the screen and in units of physical distance
• VIRTUAL_EYE, to specify that the associated distance is from the eye and in units of virtual distance
• VIRTUAL_SCREEN, to specify that the associated distance is from the screen and in units of virtual distance

Parameters:

policy - the new policy, one of PHYSICAL_EYE, PHYSICAL_SCREEN, VIRTUAL_EYE, or VIRTUAL_SCREEN

 public final int getFrontClipPolicy()

Returns the view model's current front clip policy.

Returns:

one of: PHYSICAL_EYE, PHYSICAL_SCREEN, VIRTUAL_EYE, or VIRTUAL_SCREEN

 public final void setBackClipPolicy(int policy)

Sets the view model's back clip policy, the policy Java 3D uses in computing where to place the back clip plane. The variable can contain one of:

• PHYSICAL_EYE, to specify that the associated distance is from the eye and in units of physical distance
• PHYSICAL_SCREEN, to specify that the associated distance is from the screen and in units of physical distance
• VIRTUAL_EYE, to specify that the associated distance is from the eye and in units of virtual distance
• VIRTUAL_SCREEN, to specify that the associated distance is from the screen and in units of virtual distance

Parameters:

policy - the new policy, one of PHYSICAL_EYE, PHYSICAL_SCREEN, VIRTUAL_EYE, or VIRTUAL_SCREEN

 public final int getBackClipPolicy()

Returns the view model's current back clip policy.

Returns:

one of: PHYSICAL_EYE, PHYSICAL_SCREEN, VIRTUAL_EYE, or VIRTUAL_SCREEN

 public final void setTrackingEnable(boolean flag)

Turns tracking on or off.

Parameters:

flag - enabling the display of tracking

 public final boolean getTrackingEnable()

Returns a status flag indicating whether or not tracking is enabled.

Returns:

a flag telling whether tracking is enabled

 public final void setUserHeadToVworldEnable(boolean flag)

Turns on or off the continuous updating of the userHeadToVworld transform.

Parameters:

flag - enables or disables continuous updating

 public final boolean getUserHeadToVworldEnable()

Returns a status flag indicating whether or not Java 3D is continuously updating the userHeadToVworldEnable transform.

Returns:

a flag indicating if continuously updating userHeadToVworld

 public final void getSensorToVworld(Sensor sensor,
                                     Transform3D t)

Computes the sensor to virtual-world transform and copies that value into the transform provided. The computed transforms takes points in the sensor's coordinate system and produces the point's corresponding value in virtual-world coordinates.

Parameters:

sensor - the sensor in question

t - the object that will receive the transform

 public final void getSensorHotspotInVworld(Sensor sensor,
                                            Point3f position)

Retrieves the position of the specified Sensor's last known hotspot position in virtual-world coordinates and copies that value into the vector provided. This value is derived from other values and is read-only.

Parameters:

sensor - the sensor in question

position - the vector that will receive the position

 public final void getSensorHotspotInVworld(Sensor sensor,
                                            Point3d position)

Retrieves the position of the specified Sensor's last known hotspot position in virtual-world coordinates and copies that value into the vector provided. This value is derived from other values and is read-only.

Parameters:

sensor - the sensor in question

position - the vector that will receive the position

 public final void setCanvas3D(Canvas3D canvas3D,
                               int index)

Sets given canvas3D at the given index position.

Parameters:

canvas3D - the given canvas3D to be set

index - the position to be set

 public final Canvas3D getCanvas3D(int index)

Gets the canvas3D from the given index position.

Parameters:

index - the position from which to get Canvas3D object

Returns:

canvas3D the canvas3D at index position

 public final Enumeration getAllCanvas3Ds()

Gets the enumeration object of all the canvas3Ds.

Returns:

the enumeration object of all the canvas3Ds.

 public final void addCanvas3D(Canvas3D canvas3D)

Adds the given canvas3D at the end of the list.

Parameters:

canvas3D - the canvas3D to be added

 public final void insertCanvas3D(Canvas3D canvas3D,
                                  int index)

Inserts the canvas3D at the given index position.

Parameters:

canvas3D - the canvas3D to be inserted

index - the position to be inserted at

 public final void removeCanvas3D(int index)

Removes the canvas3D from the given index position.

Parameters:

index - the position of Canvas3D object to be removed

 public final void removeCanvas3D(Canvas3D canvas3D)

Removes the given canvas3D.

Parameters:

canvas3D - the canvas3D to be removed

 public long getCurrentFrameStartTime()

This method returns the time at which the most recent rendering frame started. It is defined as the number of milliseconds since January 1, 1970 00:00:00 GMT. Since multiple canvases might be attached to this View, the start of a frame is defined as the point in time just prior to clearing any canvas attached to this view.

Returns:

the time at which the most recent rendering frame started

 public long getLastFrameDuration()

This method returns the duration, in milliseconds, of the most recently completed rendering frame. The time taken to render all canvases attached to this view is measured. This duration is computed as the difference between the start of the most recently completed frame and the end of that frame. Since multiple canvases might be attached to this View, the start of a frame is defined as the point in time just prior to clearing any canvas attached to this view, while the end of a frame is defined as the point in time just after swapping the buffer for all canvases.

Returns:

the duration, in milliseconds, of the most recently completed rendering frame

 public final void setDepthBufferFreezeTransparent(boolean flag)

Enables or disables automatic freezing of the depth buffer for objects rendered during the transparent rendering pass (i.e., objects rendered using alpha blending) for this view. If enabled, depth buffer writes will be disabled during the transparent rendering pass regardless of the value of the depth buffer write enable flag in the RenderingAttributes object for a particular node. This flag is enabled by default.

Parameters:

flag - indicates whether automatic freezing of the depth buffer for transparent/antialiased objects is enabled.

See Also:

setDepthBufferWriteEnable

 public final boolean getDepthBufferFreezeTransparent()

Retrieves the current value of the depth buffer freeze transparent flag for this view.

Returns:

a flag that indicates whether or not the depth buffer is automatically frozen during the transparent rendering pass.

 public final void setSceneAntialiasingEnable(boolean flag)

Enables or disables scene antialiasing for this view. If enabled, the entire scene will be antialiased on each canvas in which scene antialiasing is available. Scene antialiasing is disabled by default.

Parameters:

flag - indicates whether scene antialiasing is enabled

 public final boolean getSceneAntialiasingEnable()

Returns a flag that indicates whether or not scene antialiasing is enabled for this view.

Returns:

a flag that indicates whether scene antialiasing is enabled

 public final void setLocalEyeLightingEnable(boolean flag)

Sets a flag that indicates whether the local eye point is used in lighting calculations for perspective projections. If this flag is set to true, the view vector is calculated per-vertex based on the direction from the actual eye point to the vertex. If this flag is set to false, a single view vector is computed from the eye point to the center of the view frustum. This is called infinite eye lighting. Local eye lighting is disabled by default, and is ignored for parallel projections.

Parameters:

flag - indicates whether local eye lighting is enabled

 public final boolean getLocalEyeLightingEnable()

Retrieves a flag that indicates whether or not local eye lighting is enabled for this view.

Returns:

a flag that indicates whether local eye lighting is enabled

 public final void attachViewPlatform(ViewPlatform vp)

Attach viewPlatform structure to this view.

Parameters:

vp - the viewPlatform to be attached

All Packages  Class Hierarchy  This Package  Previous  Next  Index