x_ite 4.0.5 → 4.7.5

package/src/x_ite/Components/Navigation/X3DViewpointNode.js

@@ -48,7 +48,6 @@
 
 
 define ([
-	"jquery",
 	"x_ite/Fields",
 	"x_ite/Components/Core/X3DBindableNode",
 	"x_ite/Components/Time/TimeSensor",
@@ -57,13 +56,11 @@ define ([
 	"x_ite/Components/Interpolation/OrientationInterpolator",
 	"x_ite/Bits/TraverseType",
 	"x_ite/Bits/X3DConstants",
-	"standard/Math/Numbers/Vector2",
 	"standard/Math/Numbers/Vector3",
 	"standard/Math/Numbers/Rotation4",
 	"standard/Math/Numbers/Matrix4",
 ],
-function ($,
-          Fields,
+function (Fields,
           X3DBindableNode,
           TimeSensor,
           EaseInEaseOut,
@@ -71,44 +68,33 @@ function ($,
           OrientationInterpolator,
           TraverseType,
           X3DConstants,
-          Vector2,
           Vector3,
           Rotation4,
           Matrix4)
 {
 "use strict";
 
-	var
-		yAxis = new Vector3 (0, 1, 0),
-		zAxis = new Vector3 (0, 0, 1);
-
-	var
-		relativePosition         = new Vector3 (0, 0, 0),
-		relativeOrientation      = new Rotation4 (0, 0, 1, 0),
-		relativeScale            = new Vector3 (0, 0, 0),
-		relativeScaleOrientation = new Rotation4 (0, 0, 1, 0);
-			
-	var
-		localYAxis = new Vector3 (0, 0, 0),
-		direction  = new Vector3 (0, 0, 0),
-		normal     = new Vector3 (0, 0, 0),
-		vector     = new Vector3 (0, 0, 0),
-		rotation   = new Rotation4 (0, 0, 1, 0);
-
 	function X3DViewpointNode (executionContext)
 	{
 		X3DBindableNode .call (this, executionContext);
 
 		this .addType (X3DConstants .X3DViewpointNode);
 
-	   this .userPosition             = new Vector3 (0, 1, 0);
-	   this .userOrientation          = new Rotation4 (0, 0, 1, 0);
-	   this .userCenterOfRotation     = new Vector3 (0, 0, 0);
-		this .transformationMatrix     = new Matrix4 ();
-		this .cameraSpaceMatrix        = new Matrix4 (1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0,  10, 1);
-		this .inverseCameraSpaceMatrix = new Matrix4 (1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, -10, 1);
+		this .addChildObjects ("positionOffset",         new Fields .SFVec3f (),
+		                       "orientationOffset",      new Fields .SFRotation (),
+		                       "scaleOffset",            new Fields .SFVec3f (1, 1, 1),
+		                       "scaleOrientationOffset", new Fields .SFRotation (),
+		                       "centerOfRotationOffset", new Fields .SFVec3f (),
+		                       "fieldOfViewScale",       new Fields .SFFloat (1));
+
+	   this .userPosition         = new Vector3 (0, 1, 0);
+	   this .userOrientation      = new Rotation4 (0, 0, 1, 0);
+	   this .userCenterOfRotation = new Vector3 (0, 0, 0);
+		this .modelMatrix          = new Matrix4 ();
+		this .cameraSpaceMatrix    = new Matrix4 (1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0,  10, 1);
+		this .viewMatrix           = new Matrix4 (1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, -10, 1);
 
-		var browser = this .getBrowser ();
+		const browser = this .getBrowser ();
 
 		this .timeSensor                   = new TimeSensor              (browser .getPrivateScene ());
 		this .easeInEaseOut                = new EaseInEaseOut           (browser .getPrivateScene ());
@@ -118,37 +104,31 @@ function ($,
 		this .scaleOrientationInterpolator = new OrientationInterpolator (browser .getPrivateScene ());
 	}
 
-	X3DViewpointNode .prototype = $.extend (Object .create (X3DBindableNode .prototype),
+	X3DViewpointNode .prototype = Object .assign (Object .create (X3DBindableNode .prototype),
 	{
 		constructor: X3DViewpointNode,
 		initialize: function ()
 		{
 			X3DBindableNode .prototype .initialize .call (this);
 
-			this .addChildObjects ("positionOffset",         new Fields .SFVec3f (),
-			                       "orientationOffset",      new Fields .SFRotation (),
-			                       "scaleOffset",            new Fields .SFVec3f (1, 1, 1),
-			                       "scaleOrientationOffset", new Fields .SFRotation (),
-			                       "centerOfRotationOffset", new Fields .SFVec3f (),
-			                       "fieldOfViewScale",       new Fields .SFFloat (1));
-		
 			this .timeSensor .stopTime_ = 1;
 			this .timeSensor .setup ();
 
-			this .easeInEaseOut .key_           = [ 0, 1 ];
-			this .easeInEaseOut .easeInEaseOut_ = [ new Vector2 (0, 0), new Vector2 (0, 0) ];
+			this .easeInEaseOut .key_           = new Fields .MFFloat (0, 1);
+			this .easeInEaseOut .easeInEaseOut_ = new Fields .MFVec2f (new Fields .SFVec2f (0, 0), new Fields .SFVec2f (0, 0));
 			this .easeInEaseOut .setup ();
 
-			this .positionInterpolator         .key_ = [ 0, 1 ];
-			this .orientationInterpolator      .key_ = [ 0, 1 ];
-			this .scaleInterpolator            .key_ = [ 0, 1 ];
-			this .scaleOrientationInterpolator .key_ = [ 0, 1 ];
+			this .positionInterpolator         .key_ = new Fields .MFFloat (0, 1);
+			this .orientationInterpolator      .key_ = new Fields .MFFloat (0, 1);
+			this .scaleInterpolator            .key_ = new Fields .MFFloat (0, 1);
+			this .scaleOrientationInterpolator .key_ = new Fields .MFFloat (0, 1);
 
 			this .positionInterpolator         .setup ();
 			this .orientationInterpolator      .setup ();
 			this .scaleInterpolator            .setup ();
 			this .scaleOrientationInterpolator .setup ();
 
+			this .timeSensor .isActive_         .addFieldInterest (this .transitionActive_);
 			this .timeSensor .fraction_changed_ .addFieldInterest (this .easeInEaseOut .set_fraction_);
 
 			this .easeInEaseOut .modifiedFraction_changed_ .addFieldInterest (this .positionInterpolator         .set_fraction_);
@@ -168,18 +148,6 @@ function ($,
 			return this .easeInEaseOut;
 		},
 		setInterpolators: function () { },
-		bindToLayer: function (layer)
-		{
-			layer .getViewpointStack () .push (this);
-		},
-		unbindFromLayer: function (layer)
-		{
-			layer .getViewpointStack () .pop (this);
-		},
-		removeFromLayer: function (layer)
-		{
-			layer .getViewpointStack () .remove (this);
-		},
 		getPosition: function ()
 		{
 			return this .position_ .getValue ();
@@ -206,7 +174,7 @@ function ($,
 		},
 		getProjectionMatrix: function (renderObject)
 		{
-			var navigationInfo = renderObject .getNavigationInfo ();
+			const navigationInfo = renderObject .getNavigationInfo ();
 
 			return this .getProjectionMatrixWithLimits (navigationInfo .getNearValue (),
                                                      navigationInfo .getFarValue (this),
@@ -216,108 +184,153 @@ function ($,
 		{
 			return this .cameraSpaceMatrix;
 		},
-		getInverseCameraSpaceMatrix: function ()
+		getViewMatrix: function ()
+		{
+			return this .viewMatrix;
+		},
+		getModelMatrix: function ()
 		{
-			return this .inverseCameraSpaceMatrix;
+			return this .modelMatrix;
 		},
-		getTransformationMatrix: function ()
+		getMaxFarValue: function ()
 		{
-			return this .transformationMatrix;
+			return this .getBrowser () .getRenderingProperty ("LogarithmicDepthBuffer") ? 1e10 : 1e5;
 		},
 		getUpVector: function ()
 		{
 		   // Local y-axis,
 		   // see http://www.web3d.org/documents/specifications/19775-1/V3.3/index.html#NavigationInfo.
-		   return yAxis;
+		   return Vector3 .yAxis;
 		},
 		getSpeedFactor: function ()
 		{
 			return 1;
 		},
-		getMaxZFar: function ()
+		setVRMLTransition: function (value)
 		{
-			return 1e5;
+			// VRML behaviour support.
+			this .VRMLTransition = value;
 		},
-		transitionStart: function (fromViewpoint)
+		getVRMLTransition: function ()
 		{
-			try
+			// VRML behaviour support.
+			return this .VRMLTransition;
+		},
+		transitionStart: (function ()
+		{
+			const
+				relativePosition         = new Vector3 (0, 0, 0),
+				relativeOrientation      = new Rotation4 (0, 0, 1, 0),
+				relativeScale            = new Vector3 (0, 0, 0),
+				relativeScaleOrientation = new Rotation4 (0, 0, 1, 0);
+
+			return function (layerNode, fromViewpointNode, toViewpointNode)
 			{
-				if (this .jump_ .getValue ())
+				try
 				{
-					var layers = this .getLayers ();
+					this .to = toViewpointNode;
 
-					if (! this .retainUserOffsets_ .getValue ())
-						this .resetUserOffsets ();
-	
-					for (var i = 0; i < layers .length; ++ i)
+					if (toViewpointNode .jump_ .getValue ())
 					{
-						var navigationInfo = layers [i] .getNavigationInfo ();
-
-						navigationInfo .transitionStart_ = true;
+						if (! toViewpointNode .retainUserOffsets_ .getValue ())
+							toViewpointNode .resetUserOffsets ();
 
-						var
-							transitionType = navigationInfo .getTransitionType (),
-							transitionTime = navigationInfo .transitionTime_ .getValue ();
-					}
+						// Copy from toViewpointNode all fields.
 
-					switch (transitionType)
-					{
-						case "TELEPORT":
+						if (this !== toViewpointNode)
 						{
-							for (var i = 0; i < layers .length; ++ i)
-								layers [i] .getNavigationInfo () .transitionComplete_ = true;
-
-							return;
+							toViewpointNode .getFields () .forEach (function (field)
+							{
+								this .getFields () .get (field .getName ()) .assign (field);
+							}
+							.bind (this));
 						}
-						case "ANIMATE":
+
+						// Respect NavigationInfo.
+
+						const
+							navigationInfoNode = layerNode .getNavigationInfo (),
+							transitionTime     = navigationInfoNode .transitionTime_ .getValue ();
+
+						let transitionType = navigationInfoNode .getTransitionType ();
+
+						// VRML behavior
+
+						if (this .getExecutionContext () .getSpecificationVersion () == "2.0")
 						{
-							this .easeInEaseOut .easeInEaseOut_ = [ new Vector2 (0, 1), new Vector2 (1, 0) ];
-							break;
+							if (toViewpointNode .getVRMLTransition ())
+								transitionType = "LINEAR";
+							else
+								transitionType = "TELEPORT";
 						}
-						default:
+
+						toViewpointNode .setVRMLTransition (false);
+
+						// End VRML behavior
+
+						if (transitionTime <= 0)
+							transitionType = "TELEPORT";
+
+						switch (transitionType)
 						{
-							// LINEAR
-							this .easeInEaseOut .easeInEaseOut_ = [ new Vector2 (0, 0), new Vector2 (0, 0) ];
-							break;
+							case "TELEPORT":
+							{
+								navigationInfoNode .transitionComplete_ = true;
+								return;
+							}
+							case "ANIMATE":
+							{
+								this .easeInEaseOut .easeInEaseOut_ = new Fields .MFVec2f (new Fields .SFVec2f (0, 1), new Fields .SFVec2f (1, 0));
+								break;
+							}
+							default:
+							{
+								// LINEAR
+								this .easeInEaseOut .easeInEaseOut_ = new Fields .MFVec2f (new Fields .SFVec2f (0, 0), new Fields .SFVec2f (0, 0));
+								break;
+							}
 						}
-					}
-					
-					this .timeSensor .cycleInterval_ = transitionTime;
-					this .timeSensor .stopTime_      = this .getBrowser () .getCurrentTime ();
-					this .timeSensor .startTime_     = this .getBrowser () .getCurrentTime ();
-					this .timeSensor .isActive_ .addInterest ("set_active__", this);
 
-					this .getRelativeTransformation (fromViewpoint, relativePosition, relativeOrientation, relativeScale, relativeScaleOrientation);
+						this .timeSensor .cycleInterval_ = transitionTime;
+						this .timeSensor .stopTime_      = this .getBrowser () .getCurrentTime ();
+						this .timeSensor .startTime_     = this .getBrowser () .getCurrentTime ();
+
+						this .timeSensor .isActive_ .addInterest ("set_active__", this, navigationInfoNode);
 
-					this .positionInterpolator         .keyValue_ = [ relativePosition,         this .positionOffset_         .getValue () ];
-					this .orientationInterpolator      .keyValue_ = [ relativeOrientation,      this .orientationOffset_      .getValue () ];
-					this .scaleInterpolator            .keyValue_ = [ relativeScale,            this .scaleOffset_            .getValue () ];
-					this .scaleOrientationInterpolator .keyValue_ = [ relativeScaleOrientation, this .scaleOrientationOffset_ .getValue () ];
+						toViewpointNode .getRelativeTransformation (fromViewpointNode, relativePosition, relativeOrientation, relativeScale, relativeScaleOrientation);
+
+						this .positionInterpolator         .keyValue_ = new Fields .MFVec3f    (relativePosition,         toViewpointNode .positionOffset_);
+						this .orientationInterpolator      .keyValue_ = new Fields .MFRotation (relativeOrientation,      toViewpointNode .orientationOffset_);
+						this .scaleInterpolator            .keyValue_ = new Fields .MFVec3f    (relativeScale,            toViewpointNode .scaleOffset_);
+						this .scaleOrientationInterpolator .keyValue_ = new Fields .MFRotation (relativeScaleOrientation, toViewpointNode .scaleOrientationOffset_);
+
+						this .positionOffset_         = relativePosition;
+						this .orientationOffset_      = relativeOrientation;
+						this .scaleOffset_            = relativeScale;
+						this .scaleOrientationOffset_ = relativeScaleOrientation;
+
+						this .setInterpolators (fromViewpointNode, toViewpointNode);
+
+						this .transitionActive_ = true;
+					}
+					else
+					{
+						toViewpointNode .getRelativeTransformation (fromViewpointNode, relativePosition, relativeOrientation, relativeScale, relativeScaleOrientation);
 
-					this .positionOffset_         = relativePosition;
-					this .orientationOffset_      = relativeOrientation;
-					this .scaleOffset_            = relativeScale;
-					this .scaleOrientationOffset_ = relativeScaleOrientation;
+						toViewpointNode .positionOffset_         = relativePosition;
+						toViewpointNode .orientationOffset_      = relativeOrientation;
+						toViewpointNode .scaleOffset_            = relativeScale;
+						toViewpointNode .scaleOrientationOffset_ = relativeScaleOrientation;
 
-					this .setInterpolators (fromViewpoint);
+						toViewpointNode .setInterpolators (fromViewpointNode, toViewpointNode);
+					}
 				}
-				else
+				catch (error)
 				{
-					this .getRelativeTransformation (fromViewpoint, relativePosition, relativeOrientation, relativeScale, relativeScaleOrientation);
-	 
-					this .positionOffset_         = relativePosition;
-					this .orientationOffset_      = relativeOrientation;
-					this .scaleOffset_            = relativeScale;
-					this .scaleOrientationOffset_ = relativeScaleOrientation;
-
-					this .setInterpolators (fromViewpoint);
+					console .log (error);
 				}
-			}
-			catch (error)
-			{
-				console .log (error);
-			}
-		},
+			};
+		})(),
 		transitionStop: function ()
 		{
 			this .timeSensor .stopTime_ = this .getBrowser () .getCurrentTime ();
@@ -332,94 +345,140 @@ function ($,
 			this .centerOfRotationOffset_ = Vector3   .Zero;
 			this .fieldOfViewScale_       = 1;
 		},
-		getRelativeTransformation: function (fromViewpoint, relativePosition, relativeOrientation, relativeScale, relativeScaleOrientation)
+		getRelativeTransformation: function (fromViewpointNode, relativePosition, relativeOrientation, relativeScale, relativeScaleOrientation)
 		// throw
 		{
-			var differenceMatrix = this .transformationMatrix .copy () .multRight (fromViewpoint .getInverseCameraSpaceMatrix ()) .inverse ();
+			const differenceMatrix = this .modelMatrix .copy () .multRight (fromViewpointNode .getViewMatrix ()) .inverse ();
 
 			differenceMatrix .get (relativePosition, relativeOrientation, relativeScale, relativeScaleOrientation);
 
 			relativePosition .subtract (this .getPosition ());
 			relativeOrientation .assign (this .getOrientation () .copy () .inverse () .multRight (relativeOrientation));
 		},
-		straightenHorizon: function (orientation)
+		lookAtPoint: function (layerNode, point, factor, straighten)
 		{
-			// Taken from Billboard
-
-			orientation .multVecRot (direction .assign (zAxis));
-			orientation .multVecRot (localYAxis .assign (yAxis));
+			try
+			{
+				this .getCameraSpaceMatrix () .multVecMatrix (point);
 
-			normal .assign (direction) .cross (this .getUpVector ());
-			vector .assign (direction) .cross (localYAxis);
+				Matrix4 .inverse (this .getModelMatrix ()) .multVecMatrix (point);
 
-			rotation .setFromToVec (vector, normal);
+				const minDistance = layerNode .getNavigationInfo () .getNearValue () * 2;
 
-			return orientation .multRight (rotation);
+				this .lookAt (layerNode, point, minDistance, factor, straighten);
+			}
+			catch (error)
+			{
+				console .error (error);
+			}
 		},
-		lookAtPoint: function (point, factor, straighten)
+		lookAtBBox: function (layerNode, bbox, factor, straighten)
 		{
-			if (! this .getBrowser () .getActiveLayer ())
-				return;
-
 			try
 			{
-				this .getCameraSpaceMatrix () .multVecMatrix (point);
+				bbox = bbox .copy () .multRight (Matrix4 .inverse (this .getModelMatrix ()));
 
-				Matrix4 .inverse (this .getTransformationMatrix ()) .multVecMatrix (point);
+				const minDistance = layerNode .getNavigationInfo () .getNearValue () * 2;
 
-				var minDistance = this .getBrowser () .getActiveLayer () .getNavigationInfo () .getNearValue () * 2;
-		
-				this .lookAt (point, minDistance, factor, straighten);
+				this .lookAt (layerNode, bbox .center, minDistance, factor, straighten);
 			}
 			catch (error)
 			{
-				console .error (error);
+				console .log (error);
 			}
 		},
-		lookAt: function (point, distance, factor, straighten)
+		lookAt: function (layerNode, point, distance, factor, straighten)
 		{
-			var
-				layers = this .getLayers (),
+			const
 				offset = point .copy () .add (this .getUserOrientation () .multVecRot (new Vector3 (0, 0, distance))) .subtract (this .getPosition ());
 
-			for (var i = 0; i < layers .length; ++ i)
-				layers [i] .getNavigationInfo () .transitionStart_ = true;;
-		
+			layerNode .getNavigationInfo () .transitionStart_ = true;
+
 			this .timeSensor .cycleInterval_ = 0.2;
 			this .timeSensor .stopTime_      = this .getBrowser () .getCurrentTime ();
 			this .timeSensor .startTime_     = this .getBrowser () .getCurrentTime ();
-			this .timeSensor .isActive_ .addInterest ("set_active__", this);
-	
-			this .easeInEaseOut .easeInEaseOut_ = [ new Vector2 (0, 1), new Vector2 (1, 0) ];
 
-			var
+			this .timeSensor .isActive_ .addInterest ("set_active__", this, layerNode .getNavigationInfo ());
+
+			this .easeInEaseOut .easeInEaseOut_ = new Fields .MFVec2f (new Fields .SFVec2f (0, 1), new Fields .SFVec2f (1, 0));
+
+			const
 				translation = Vector3 .lerp (this .positionOffset_ .getValue (), offset, factor),
-				direction   = Vector3 .add (this .getPosition (), translation) .subtract (point),
-				rotation    = Rotation4 .multRight (this .orientationOffset_ .getValue (), new Rotation4 (this .getUserOrientation () .multVecRot (new Vector3 (0, 0, 1)), direction));
-		
+				direction   = Vector3 .add (this .getPosition (), translation) .subtract (point);
+
+			let rotation = Rotation4 .multRight (this .orientationOffset_ .getValue (), new Rotation4 (this .getUserOrientation () .multVecRot (new Vector3 (0, 0, 1)), direction));
+
 			if (straighten)
+			{
 				rotation = Rotation4 .inverse (this .getOrientation ()) .multRight (this .straightenHorizon (Rotation4 .multRight (this .getOrientation (), rotation)));
-		
-			this .positionInterpolator         .keyValue_ = [ this .positionOffset_ .getValue (),         translation ];
-			this .orientationInterpolator      .keyValue_ = [ this .orientationOffset_ .getValue (),      rotation ];
-			this .scaleInterpolator            .keyValue_ = [ this .scaleOffset_ .getValue (),            this .scaleOffset_ .getValue () ];
-			this .scaleOrientationInterpolator .keyValue_ = [ this .scaleOrientationOffset_ .getValue (), this .scaleOrientationOffset_ .getValue () ];
-		
+			}
+
+			this .positionInterpolator         .keyValue_ = new Fields .MFVec3f (this .positionOffset_, translation);
+			this .orientationInterpolator      .keyValue_ = new Fields .MFRotation (this .orientationOffset_, rotation);
+			this .scaleInterpolator            .keyValue_ = new Fields .MFVec3f (this .scaleOffset_, this .scaleOffset_);
+			this .scaleOrientationInterpolator .keyValue_ = new Fields .MFRotation (this .scaleOrientationOffset_, this .scaleOrientationOffset_);
+
+			this .setInterpolators (this, this);
+
 			this .centerOfRotationOffset_ = Vector3 .subtract (point, this .getCenterOfRotation ());
 			this .set_bind_               = true;
 		},
-		set_active__: function (active)
+		straighten: function (layerNode, horizon)
 		{
-			if (! active .getValue () && this .timeSensor .fraction_changed_ .getValue () === 1)
+			layerNode .getNavigationInfo () .transitionStart_ = true;
+
+			this .timeSensor .cycleInterval_ = 0.4;
+			this .timeSensor .stopTime_      = this .getBrowser () .getCurrentTime ();
+			this .timeSensor .startTime_     = this .getBrowser () .getCurrentTime ();
+
+			this .timeSensor .isActive_ .addInterest ("set_active__", this, layerNode .getNavigationInfo ());
+
+			this .easeInEaseOut .easeInEaseOut_ = new Fields .MFVec2f (new Fields .SFVec2f (0, 1), new Fields .SFVec2f (1, 0));
+
+			const rotation = Rotation4 .multRight (Rotation4 .inverse (this .getOrientation ()), this .straightenHorizon (this .getUserOrientation ()));
+
+			this .positionInterpolator         .keyValue_ = new Fields .MFVec3f (this .positionOffset_, this .positionOffset_);
+			this .orientationInterpolator      .keyValue_ = new Fields .MFRotation (this .orientationOffset_, rotation);
+			this .scaleInterpolator            .keyValue_ = new Fields .MFVec3f (this .scaleOffset_, this .scaleOffset_);
+			this .scaleOrientationInterpolator .keyValue_ = new Fields .MFRotation (this .scaleOrientationOffset_, this .scaleOrientationOffset_);
+
+			this .setInterpolators (this, this);
+
+			this .set_bind_ = true;
+		},
+		straightenHorizon: (function ()
+		{
+			const
+				localXAxis  = new Vector3 (0, 0, 0),
+				localZAxis  = new Vector3 (0, 0, 0),
+				rotation    = new Rotation4 (0, 0, 1, 0);
+
+			return function (orientation)
 			{
-				var layers = this .getLayers ();
+				orientation .multVecRot (localXAxis .assign (Vector3 .xAxis) .negate ());
+				orientation .multVecRot (localZAxis .assign (Vector3 .zAxis));
 
-				for (var i = 0; i < layers .length; ++ i)
-				{
-					layers [i] .getNavigationInfo () .transitionComplete_ = true;
-				}
+				const
+				 	upVector = this .getUpVector (),
+					vector   = localZAxis .cross (upVector);
 
-				this .easeInEaseOut .set_fraction_ = 1;
+				// If viewer looks along the up vector.
+				if (Math .abs (localZAxis .dot (upVector)) >= 1)
+					return orientation;
+
+				if (Math .abs (vector .dot (localXAxis)) >= 1)
+					return orientation;
+
+				rotation .setFromToVec (localXAxis, vector);
+
+				return orientation .multRight (rotation);
+			};
+		})(),
+		set_active__: function (active, navigationInfoNode)
+		{
+			if (this .isBound_ .getValue () && ! active .getValue () && this .timeSensor .fraction_changed_ .getValue () === 1)
+			{
+				navigationInfoNode .transitionComplete_ = true;
 			}
 		},
 		set_bound__: function ()
@@ -431,31 +490,32 @@ function ($,
 		},
 		traverse: function (type, renderObject)
 		{
+			if (type !== TraverseType .CAMERA)
+				return;
+
 			renderObject .getLayer () .getViewpoints () .push (this);
 
-			this .transformationMatrix .assign (renderObject .getModelViewMatrix () .get ());
+			this .modelMatrix .assign (renderObject .getModelViewMatrix () .get ());
 		},
 		update: function ()
 		{
 			try
 			{
 				this .cameraSpaceMatrix .set (this .getUserPosition (),
-				                              this .getUserOrientation (),
-				                              this .scaleOffset_ .getValue (),
-				                              this .scaleOrientationOffset_ .getValue ());
+														this .getUserOrientation (),
+														this .scaleOffset_ .getValue (),
+														this .scaleOrientationOffset_ .getValue ());
 
-				this .cameraSpaceMatrix .multRight (this .transformationMatrix);
+				this .cameraSpaceMatrix .multRight ((this .to || this) .modelMatrix);
 
-				this .inverseCameraSpaceMatrix .assign (this .cameraSpaceMatrix) .inverse ();
+				this .viewMatrix .assign (this .cameraSpaceMatrix) .inverse ();
 			}
 			catch (error)
 			{
-			   console .log (error);
+				console .log (error);
 			}
-		},
+		}
 	});
 
 	return X3DViewpointNode;
 });
-
-