x_ite 4.2.17 → 4.7.7

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

@@ -76,7 +76,7 @@ function (Fields,
 
 		this .addType (X3DConstants .LOD);
 
-		if (executionContext .getSpecificationVersion () == "2.0")
+		if (executionContext .getSpecificationVersion () === "2.0")
 			this .addAlias ("level", this .children_); // VRML2
 
 		this .center_ .setUnit ("length");
@@ -84,6 +84,9 @@ function (Fields,
 
 		this .frameRate        = 60;
 		this .keepCurrentLevel = false;
+		this .childNode        = null;
+		this .visibleNode      = null;
+		this .boundedObject    = null;
 	}
 
 	LOD .prototype = Object .assign (Object .create (X3DGroupingNode .prototype),
@@ -95,6 +98,8 @@ function (Fields,
 			new X3DFieldDefinition (X3DConstants .initializeOnly, "center",           new Fields .SFVec3f ()),
 			new X3DFieldDefinition (X3DConstants .initializeOnly, "range",            new Fields .MFFloat ()),
 			new X3DFieldDefinition (X3DConstants .outputOnly,     "level_changed",    new Fields .SFInt32 (-1)),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "visible",          new Fields .SFBool (true)),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "bboxDisplay",      new Fields .SFBool ()),
 			new X3DFieldDefinition (X3DConstants .initializeOnly, "bboxSize",         new Fields .SFVec3f (-1, -1, -1)),
 			new X3DFieldDefinition (X3DConstants .initializeOnly, "bboxCenter",       new Fields .SFVec3f ()),
 			new X3DFieldDefinition (X3DConstants .inputOnly,      "addChildren",      new Fields .MFNode ()),
@@ -117,33 +122,121 @@ function (Fields,
 		{
 			X3DGroupingNode .prototype .initialize .call (this);
 
-			this .child = this .getChild (this .level_changed_ .getValue ());
-			this .set_cameraObjects__ ();
+			this .children_ .addInterest ("set_child__", this);
 		},
-		set_cameraObjects__: function ()
+		getSubBBox: function (bbox, shadow)
 		{
-			if (this .child && this .child .getCameraObject)
-				this .setCameraObject (this .child .getCameraObject ());
-			else
-				this .setCameraObject (false);
-		},
-		getBBox: function (bbox) 
-		{
-			if (this .bboxSize_ .getValue () .equals (this .defaultBBoxSize))
+			if (this .bboxSize_ .getValue () .equals (this .getDefaultBBoxSize ()))
 			{
-				var boundedObject = X3DCast (X3DConstants .X3DBoundedObject, this .child);
+				const boundedObject = X3DCast (X3DConstants .X3DBoundedObject, this .visibleNode);
 
 				if (boundedObject)
-					return boundedObject .getBBox (bbox);
+					return boundedObject .getBBox (bbox, shadow);
 
 				return bbox .set ();
 			}
 
 			return bbox .set (this .bboxSize_ .getValue (), this .bboxCenter_ .getValue ());
 		},
+		clear: function () { },
+		add: function () { },
+		remove: function () { },
+		set_child__: function ()
+		{
+			this .set_level__ (Math .min (this .level_changed_ .getValue (), this .children_ .length - 1));
+		},
+		set_level__: function (level)
+		{
+			if (this .childNode)
+			{
+				this .childNode .isCameraObject_   .removeInterest ("set_cameraObject__",     this);
+				this .childNode .isPickableObject_ .removeInterest ("set_transformSensors__", this);
+			}
+
+			if (X3DCast (X3DConstants .X3DBoundedObject, this .childNode))
+			{
+				this .childNode .visible_     .removeInterest ("set_visible__",     this);
+				this .childNode .bboxDisplay_ .removeInterest ("set_bboxDisplay__", this);
+			}
+
+			if (level >= 0 && level < this .children_ .length)
+			{
+				this .childNode = X3DCast (X3DConstants .X3DChildNode, this .children_ [level]);
+
+				if (this .childNode)
+				{
+					this .childNode .isCameraObject_   .addInterest ("set_cameraObject__",     this);
+					this .childNode .isPickableObject_ .addInterest ("set_transformSensors__", this);
+
+					if (X3DCast (X3DConstants .X3DBoundedObject, this .childNode))
+					{
+						this .childNode .visible_     .addInterest ("set_visible__",     this);
+						this .childNode .bboxDisplay_ .addInterest ("set_bboxDisplay__", this);
+					}
+
+					//delete this .traverse;
+				}
+			}
+			else
+			{
+				this .childNode = null;
+
+				//this .traverse = Function .prototype; // Don't do that.
+			}
+
+			this .set_transformSensors__ ();
+			this .set_visible__ ();
+			this .set_bboxDisplay__ ();
+		},
+		set_cameraObject__: function ()
+		{
+			if (this .childNode && this .childNode .getCameraObject ())
+			{
+				if (X3DCast (X3DConstants .X3DBoundedObject, this .childNode))
+				{
+					this .setCameraObject (this .childNode .visible_ .getValue ());
+				}
+				else
+				{
+					this .setCameraObject (true);
+				}
+			}
+			else
+			{
+				this .setCameraObject (false);
+			}
+		},
+		set_transformSensors__: function ()
+		{
+			this .setPickableObject (Boolean (this .getTransformSensors () .size || this .childNode && this .childNode .getPickableObject ()));
+		},
+		set_visible__: function ()
+		{
+			if (X3DCast (X3DConstants .X3DBoundedObject, this .childNode))
+			{
+				this .visibleNode = this .childNode .visible_ .getValue () ? this .childNode : null;
+			}
+			else
+			{
+				this .visibleNode = this .childNode;
+			}
+
+			this .set_cameraObject__ ();
+		},
+		set_bboxDisplay__: function ()
+		{
+			if (X3DCast (X3DConstants .X3DBoundedObject, this .childNode))
+			{
+				this .boundedObject = this .childNode .bboxDisplay_ .getValue () ? this .childNode : null;
+			}
+			else
+			{
+				this .boundedObject = null;
+			}
+		},
 		getLevel: (function ()
 		{
-			var
+			const
 				FRAMES         = 180, // Number of frames after wich a level change takes in affect.
 				FRAME_RATE_MIN = 20,  // Lowest level of detail.
 				FRAME_RATE_MAX = 55;  // Highest level of detail.
@@ -152,73 +245,128 @@ function (Fields,
 			{
 				if (this .range_ .length === 0)
 				{
-					var size = this .children_ .length;
-	
-					if (size < 2)
-						return 0;
-	
 					this .frameRate = ((FRAMES - 1) * this .frameRate + browser .currentFrameRate) / FRAMES;
-	
-					if (size === 2)
-						return Number (this .frameRate > FRAME_RATE_MAX);
-	
-					var fraction = 1 - Algorithm .clamp ((this .frameRate - FRAME_RATE_MIN) / (FRAME_RATE_MAX - FRAME_RATE_MIN), 0, 1);
 
-					return Math .min (Math .floor (fraction * size), size - 1);
+					const size = this .children_ .length;
+
+					switch (size)
+					{
+						case 0:
+							return -1;
+						case 1:
+							return 0;
+						case 2:
+							return (this .frameRate > FRAME_RATE_MAX) * 1;
+						default:
+						{
+							const fraction = 1 - Algorithm .clamp ((this .frameRate - FRAME_RATE_MIN) / (FRAME_RATE_MAX - FRAME_RATE_MIN), 0, 1);
+
+							return Math .min (Math .floor (fraction * size), size - 1);
+						}
+					}
 				}
-	
-				var distance = this .getDistance (modelViewMatrix);
-	
+
+				const distance = modelViewMatrix .translate (this .center_ .getValue ()) .origin .abs ();
+
 				return Algorithm .upperBound (this .range_, 0, this .range_ .length, distance, Algorithm .less);
 			};
 		})(),
-		getDistance: function (modelViewMatrix)
-		{
-			modelViewMatrix .translate (this .center_ .getValue ());
-
-			return modelViewMatrix .origin .abs ();
-		},
 		traverse: (function ()
 		{
-			var modelViewMatrix = new Matrix4 ();
+			const modelViewMatrix = new Matrix4 ();
 
 			return function (type, renderObject)
 			{
-				if (! this .keepCurrentLevel)
+				switch (type)
 				{
-					if (type === TraverseType .DISPLAY)
+					case TraverseType .POINTER:
+					case TraverseType .CAMERA:
+					case TraverseType .SHADOW:
+					{
+						const visibleNode = this .visibleNode;
+
+						if (visibleNode)
+							visibleNode .traverse (type, renderObject);
+
+						return;
+					}
+					case TraverseType .PICKING:
 					{
-						var
-							level        = this .getLevel (renderObject .getBrowser (), modelViewMatrix .assign (renderObject .getModelViewMatrix () .get ())),
-							currentLevel = this .level_changed_ .getValue ();
+						if (this .getTransformSensors () .size)
+						{
+							const modelMatrix = renderObject .getModelViewMatrix () .get ();
 
-						if (this .forceTransitions_ .getValue ())
+							for (const transformSensorNode of this .getTransformSensors ())
+								transformSensorNode .collect (modelMatrix);
+						}
+
+						const childNode = this .childNode;
+
+						if (childNode)
 						{
-							if (level > currentLevel)
-								level = currentLevel + 1;
-		
-							else if (level < currentLevel)
-								level = currentLevel - 1;
+							const
+								browser          = renderObject .getBrowser (),
+								pickingHierarchy = browser .getPickingHierarchy ();
+
+							pickingHierarchy .push (this);
+
+							childNode .traverse (type, renderObject);
+
+							pickingHierarchy .pop ();
 						}
-	
-						if (level !== currentLevel)
+
+						return;
+					}
+					case TraverseType .COLLISION:
+					{
+						const childNode = this .childNode;
+
+						if (childNode)
+							childNode .traverse (type, renderObject);
+
+						return;
+					}
+					case TraverseType .DISPLAY:
+					{
+						if (! this .keepCurrentLevel)
 						{
-							this .level_changed_ = level;
-					
-							this .child = this .getChild (Math .min (level, this .children_ .length - 1));
-	
-							this .set_cameraObjects__ ();
+							var
+								level        = this .getLevel (renderObject .getBrowser (), modelViewMatrix .assign (renderObject .getModelViewMatrix () .get ())),
+								currentLevel = this .level_changed_ .getValue ();
+
+							if (this .forceTransitions_ .getValue ())
+							{
+								if (level > currentLevel)
+									level = currentLevel + 1;
+
+								else if (level < currentLevel)
+									level = currentLevel - 1;
+							}
+
+							if (level !== currentLevel)
+							{
+								this .level_changed_ = level;
+
+								this .set_level__ (Math .min (level, this .children_ .length - 1));
+							}
 						}
+
+						const visibleNode = this .visibleNode;
+
+						if (visibleNode)
+							visibleNode .traverse (type, renderObject);
+
+						const boundedObject = this .boundedObject;
+
+						if (boundedObject)
+							boundedObject .displayBBox (type, renderObject);
+
+						return;
 					}
 				}
-	
-				if (this .child)
-					this .child .traverse (type, renderObject);
 			};
 		})(),
 	});
 
 	return LOD;
 });
-
-

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

@@ -76,9 +76,8 @@ function (Fields,
 		X3DBindableNode .call (this, executionContext);
 
 		this .addType (X3DConstants .NavigationInfo);
-				
+
 		this .addChildObjects ("transitionStart",  new Fields .SFBool (),
-		                       "transitionActive", new Fields .SFBool (),
 		                       "availableViewers", new Fields .MFString (),
 		                       "viewer",           new Fields .SFString ("EXAMINE"));
 
@@ -189,16 +188,6 @@ function (Fields,
 		},
 		set_type__: function ()
 		{
-			this .availableViewers_ .length = 0;;
-
-			var
-				examineViewer = false,
-				walkViewer    = false,
-				flyViewer     = false,
-				planeViewer   = false,
-				noneViewer    = false,
-				lookAt        = false;
-
 			// Determine active viewer.
 
 			this .viewer_ = "EXAMINE";
@@ -206,7 +195,7 @@ function (Fields,
 			for (var i = 0; i < this .type_ .length; ++ i)
 			{
 			   var string = this .type_ [i];
-			
+
 				switch (string)
 				{
 					case "EXAMINE":
@@ -230,6 +219,14 @@ function (Fields,
 
 			// Determine available viewers.
 
+			var
+				examineViewer = false,
+				walkViewer    = false,
+				flyViewer     = false,
+				planeViewer   = false,
+				noneViewer    = false,
+				lookAt        = false;
+
 			if (! this .type_ .length)
 			{
 				examineViewer = true;
@@ -265,26 +262,26 @@ function (Fields,
 						case "NONE":
 							noneViewer = true;
 							continue;
+						case "ANY":
+							examineViewer = true;
+							walkViewer    = true;
+							flyViewer     = true;
+							planeViewer   = true;
+							noneViewer    = true;
+							lookAt        = true;
+							break;
+						default:
+							// Some string defaults to EXAMINE.
+							examineViewer = true;
+							continue;
 					}
 
-					if (string == "ANY")
-					{
-						examineViewer = true;
-						walkViewer    = true;
-						flyViewer     = true;
-						planeViewer   = true;
-						noneViewer    = true;
-						lookAt        = true;
-
-						// Leave for loop.
-						break;
-					}
-
-					// Some string defaults to EXAMINE.
-					examineViewer = true;
+					break;
 				}
 			}
 
+			this .availableViewers_ .length = 0;
+
 			if (examineViewer)
 				this .availableViewers_ .push ("EXAMINE");
 
@@ -328,33 +325,22 @@ function (Fields,
 			if (this .transitionActive_ .getValue ())
 				this .transitionActive_ = false;
 		},
-		bindToLayer: function (layer)
-		{
-			layer .getNavigationInfoStack () .push (this);
-		},
-		unbindFromLayer: function (layer)
-		{
-			layer .getNavigationInfoStack () .pop (this);
-		},
-		removeFromLayer: function (layer)
-		{
-			layer .getNavigationInfoStack () .remove (this);
-		},
 		enable: function (type, renderObject)
 		{
 			if (type !== TraverseType .DISPLAY)
 				return;
 
 			if (this .headlight_ .getValue ())
-				renderObject .getGlobalLights () .push (renderObject .getBrowser () .getHeadlight ());
+				renderObject .getGlobalObjects () .push (renderObject .getBrowser () .getHeadlight ());
 		},
 		traverse: function (type, renderObject)
 		{
+			if (type !== TraverseType .CAMERA)
+				return;
+
 			renderObject .getLayer () .getNavigationInfos () .push (this);
 		}
 	});
 
 	return NavigationInfo;
 });
-
-

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

@@ -52,6 +52,7 @@ define ([
 	"x_ite/Basic/X3DFieldDefinition",
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/Navigation/X3DViewpointNode",
+	"x_ite/Components/Interpolation/ScalarInterpolator",
 	"x_ite/Bits/X3DConstants",
 	"standard/Math/Geometry/Camera",
 	"standard/Math/Numbers/Vector2",
@@ -61,7 +62,8 @@ define ([
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DViewpointNode, 
+          X3DViewpointNode,
+          ScalarInterpolator,
           X3DConstants,
           Camera,
           Vector2,
@@ -76,11 +78,18 @@ function (Fields,
 
 		this .addType (X3DConstants .OrthoViewpoint);
 
+		this .addChildObjects ("fieldOfViewOffset", new Fields .MFFloat (0, 0, 0, 0));
+
 		this .position_         .setUnit ("length");
 		this .centerOfRotation_ .setUnit ("length");
 		this .fieldOfView_      .setUnit ("length");
 
-		this .projectionMatrix = new Matrix4 ();
+		this .projectionMatrix               = new Matrix4 ();
+		this .fieldOfViewOffsetInterpolator0 = new ScalarInterpolator (this .getBrowser () .getPrivateScene ());
+		this .fieldOfViewOffsetInterpolator1 = new ScalarInterpolator (this .getBrowser () .getPrivateScene ());
+		this .fieldOfViewOffsetInterpolator2 = new ScalarInterpolator (this .getBrowser () .getPrivateScene ());
+		this .fieldOfViewOffsetInterpolator3 = new ScalarInterpolator (this .getBrowser () .getPrivateScene ());
+		this .fieldOfViewScaleInterpolator   = new ScalarInterpolator (this .getBrowser () .getPrivateScene ());
 	}
 
 	OrthoViewpoint .prototype = Object .assign (Object .create (X3DViewpointNode .prototype),
@@ -115,25 +124,99 @@ function (Fields,
 		{
 			X3DViewpointNode .prototype .initialize .call (this);
 
-			this .fieldOfView_      .addInterest ("set_fieldOfView___", this);
-			this .fieldOfViewScale_ .addInterest ("set_fieldOfView___", this);
+			this .fieldOfView_       .addInterest ("set_fieldOfView__", this);
+			this .fieldOfViewOffset_ .addInterest ("set_fieldOfView__", this);
+			this .fieldOfViewScale_  .addInterest ("set_fieldOfView__", this);
+
+			this .fieldOfViewOffsetInterpolator0 .key_ = new Fields .MFFloat (0, 1);
+			this .fieldOfViewOffsetInterpolator1 .key_ = new Fields .MFFloat (0, 1);
+			this .fieldOfViewOffsetInterpolator2 .key_ = new Fields .MFFloat (0, 1);
+			this .fieldOfViewOffsetInterpolator3 .key_ = new Fields .MFFloat (0, 1);
+			this .fieldOfViewScaleInterpolator   .key_ = new Fields .MFFloat (0, 1);
+
+			this .fieldOfViewOffsetInterpolator0 .setup ();
+			this .fieldOfViewOffsetInterpolator1 .setup ();
+			this .fieldOfViewOffsetInterpolator2 .setup ();
+			this .fieldOfViewOffsetInterpolator3 .setup ();
+			this .fieldOfViewScaleInterpolator   .setup ();
+
+			this .getEaseInEaseOut () .modifiedFraction_changed_ .addFieldInterest (this .fieldOfViewOffsetInterpolator0 .set_fraction_);
+			this .getEaseInEaseOut () .modifiedFraction_changed_ .addFieldInterest (this .fieldOfViewOffsetInterpolator1 .set_fraction_);
+			this .getEaseInEaseOut () .modifiedFraction_changed_ .addFieldInterest (this .fieldOfViewOffsetInterpolator2 .set_fraction_);
+			this .getEaseInEaseOut () .modifiedFraction_changed_ .addFieldInterest (this .fieldOfViewOffsetInterpolator3 .set_fraction_);
+			this .getEaseInEaseOut () .modifiedFraction_changed_ .addFieldInterest (this .fieldOfViewScaleInterpolator   .set_fraction_);
 
-			this .set_fieldOfView___ ();
+			this .fieldOfViewOffsetInterpolator0 .value_changed_ .addInterest ("set_fieldOfViewOffset__", this);
+			this .fieldOfViewOffsetInterpolator1 .value_changed_ .addInterest ("set_fieldOfViewOffset__", this);
+			this .fieldOfViewOffsetInterpolator2 .value_changed_ .addInterest ("set_fieldOfViewOffset__", this);
+			this .fieldOfViewOffsetInterpolator3 .value_changed_ .addInterest ("set_fieldOfViewOffset__", this);
+
+			this .fieldOfViewScaleInterpolator .value_changed_ .addFieldInterest (this .fieldOfViewScale_);
+
+			this .set_fieldOfView__ ();
 		},
-		set_fieldOfView___: function ()
+		set_fieldOfView__: function ()
 		{
 			var
 				length           = this .fieldOfView_ .length,
 				fieldOfViewScale = this .fieldOfViewScale_ .getValue ();
 
-			this .minimumX = (length > 0 ? this .fieldOfView_ [0] : -1) * fieldOfViewScale;
-			this .minimumY = (length > 1 ? this .fieldOfView_ [1] : -1) * fieldOfViewScale;
-			this .maximumX = (length > 2 ? this .fieldOfView_ [2] :  1) * fieldOfViewScale;
-			this .maximumY = (length > 3 ? this .fieldOfView_ [3] :  1) * fieldOfViewScale;
+			this .minimumX = ((length > 0 ? this .fieldOfView_ [0] : -1) + this .fieldOfViewOffset_ [0]) * fieldOfViewScale;
+			this .minimumY = ((length > 1 ? this .fieldOfView_ [1] : -1) + this .fieldOfViewOffset_ [1]) * fieldOfViewScale;
+			this .maximumX = ((length > 2 ? this .fieldOfView_ [2] :  1) + this .fieldOfViewOffset_ [2]) * fieldOfViewScale;
+			this .maximumY = ((length > 3 ? this .fieldOfView_ [3] :  1) + this .fieldOfViewOffset_ [3]) * fieldOfViewScale;
 
 			this .sizeX = this .maximumX - this .minimumX;
 			this .sizeY = this .maximumY - this .minimumY;
 		},
+		set_fieldOfViewOffset__: function ()
+		{
+			this .fieldOfViewOffset_ [0] = this .fieldOfViewOffsetInterpolator0 .value_changed_ .getValue ();
+			this .fieldOfViewOffset_ [1] = this .fieldOfViewOffsetInterpolator1 .value_changed_ .getValue ();
+			this .fieldOfViewOffset_ [2] = this .fieldOfViewOffsetInterpolator2 .value_changed_ .getValue ();
+			this .fieldOfViewOffset_ [3] = this .fieldOfViewOffsetInterpolator3 .value_changed_ .getValue ();
+		},
+		setInterpolators: function (fromViewpointNode, toViewpointNode)
+		{
+			if (fromViewpointNode .getType () .indexOf (X3DConstants .OrthoViewpoint) >= 0)
+			{
+				const
+					toLength   = toViewpointNode   .fieldOfView_ .length,
+					fromLength = fromViewpointNode .fieldOfView_ .length;
+
+				const
+					offset0 = (fromLength > 0 ? fromViewpointNode .fieldOfView_ [0] : -1) - (toLength > 0 ? toViewpointNode .fieldOfView_ [0] : -1),
+					offset1 = (fromLength > 1 ? fromViewpointNode .fieldOfView_ [1] : -1) - (toLength > 1 ? toViewpointNode .fieldOfView_ [1] : -1),
+					offset2 = (fromLength > 2 ? fromViewpointNode .fieldOfView_ [2] :  1) - (toLength > 2 ? toViewpointNode .fieldOfView_ [2] :  1),
+					offset3 = (fromLength > 3 ? fromViewpointNode .fieldOfView_ [3] :  1) - (toLength > 3 ? toViewpointNode .fieldOfView_ [3] :  1);
+
+				this .fieldOfViewOffsetInterpolator0 .keyValue_ = new Fields .MFFloat (offset0, toViewpointNode .fieldOfViewOffset_ [0]);
+				this .fieldOfViewOffsetInterpolator1 .keyValue_ = new Fields .MFFloat (offset1, toViewpointNode .fieldOfViewOffset_ [1]);
+				this .fieldOfViewOffsetInterpolator2 .keyValue_ = new Fields .MFFloat (offset2, toViewpointNode .fieldOfViewOffset_ [2]);
+				this .fieldOfViewOffsetInterpolator3 .keyValue_ = new Fields .MFFloat (offset3, toViewpointNode .fieldOfViewOffset_ [3]);
+
+				this .fieldOfViewScaleInterpolator .keyValue_ = new Fields .MFFloat (fromViewpointNode .fieldOfViewScale_ .getValue (), toViewpointNode .fieldOfViewScale_ .getValue ());
+
+				this .fieldOfViewOffset_ [0] = offset0;
+				this .fieldOfViewOffset_ [1] = offset1;
+				this .fieldOfViewOffset_ [2] = offset2;
+				this .fieldOfViewOffset_ [3] = offset3;
+
+				this .fieldOfViewScale_ = fromViewpointNode .fieldOfViewScale_ .getValue ();
+			}
+			else
+			{
+				this .fieldOfViewOffsetInterpolator0 .keyValue_ = new Fields .MFFloat (toViewpointNode .fieldOfViewOffset_ [0], toViewpointNode .fieldOfViewOffset_ [0]);
+				this .fieldOfViewOffsetInterpolator1 .keyValue_ = new Fields .MFFloat (toViewpointNode .fieldOfViewOffset_ [1], toViewpointNode .fieldOfViewOffset_ [1]);
+				this .fieldOfViewOffsetInterpolator2 .keyValue_ = new Fields .MFFloat (toViewpointNode .fieldOfViewOffset_ [2], toViewpointNode .fieldOfViewOffset_ [2]);
+				this .fieldOfViewOffsetInterpolator3 .keyValue_ = new Fields .MFFloat (toViewpointNode .fieldOfViewOffset_ [3], toViewpointNode .fieldOfViewOffset_ [3]);
+
+				this .fieldOfViewScaleInterpolator .keyValue_ = new Fields .MFFloat (toViewpointNode .fieldOfViewScale_ .getValue (), toViewpointNode .fieldOfViewScale_ .getValue ());
+
+				this .fieldOfViewOffset_ = toViewpointNode .fieldOfViewOffset_ .getValue ();
+				this .fieldOfViewScale_  = toViewpointNode .fieldOfViewScale_  .getValue ();
+			}
+		},
 		getMinimumX: function ()
 		{
 			return this .minimumX;
@@ -174,16 +257,16 @@ function (Fields,
 					sizeX  = this .sizeX,
 					sizeY  = this .sizeY,
 					aspect = width / height;
-	
+
 				if (aspect > sizeX / sizeY)
 				{
 					var s = sizeY / height;
-	
+
 					return screenScale .set (s, s, s);
 				}
-	
+
 				var s = sizeX / width;
-	
+
 				return screenScale .set (s, s, s);
 			};
 		})(),
@@ -199,10 +282,10 @@ function (Fields,
 					sizeX  = this .sizeX,
 					sizeY  = this .sizeY,
 					aspect = width / height;
-	
+
 				if (aspect > sizeX / sizeY)
 					return viewportSize .set (sizeY * aspect, sizeY);
-	
+
 				return viewportSize .set (sizeX, sizeX / aspect);
 			};
 		})(),
@@ -238,5 +321,3 @@ function (Fields,
 
 	return OrthoViewpoint;
 });
-
-