x_ite 4.0.5 → 4.7.5

package/src/x_ite/Execution/X3DExecutionContext.js

@@ -48,12 +48,8 @@
 
 
 define ([
-	"jquery",
 	"x_ite/Fields",
-	"x_ite/Basic/X3DFieldDefinition",
-	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Basic/X3DBaseNode",
-	"x_ite/Configuration/ComponentInfoArray",
 	"x_ite/Execution/ImportedNode",
 	"x_ite/Prototype/ExternProtoDeclarationArray",
 	"x_ite/Prototype/ProtoDeclarationArray",
@@ -61,16 +57,12 @@ define ([
 	"x_ite/Routing/X3DRoute",
 	"x_ite/Bits/X3DCast",
 	"x_ite/Bits/X3DConstants",
-	"standard/Networking/URI",
-	"standard/Math/Algorithm",
 	"x_ite/InputOutput/Generator",
+	"x_ite/Fields/SFNodeCache",
+	"standard/Math/Algorithm",
 ],
-function ($,
-          Fields,
-          X3DFieldDefinition,
-          FieldDefinitionArray,
+function (Fields,
           X3DBaseNode,
-          ComponentInfoArray,
           ImportedNode,
           ExternProtoDeclarationArray,
           ProtoDeclarationArray,
@@ -78,9 +70,9 @@ function ($,
           X3DRoute,
           X3DCast,
           X3DConstants,
-          URI,
-          Algorithm,
-          Generator)
+          Generator,
+          SFNodeCache,
+          Algorithm)
 {
 "use strict";
 
@@ -90,44 +82,22 @@ function ($,
 
 		this .addChildObjects ("rootNodes", new Fields .MFNode ());
 
-		this .specificationVersion = "3.3";
-		this .encoding             = "SCRIPTED";
-		this .profile              = null;
-		this .components           = new ComponentInfoArray (this .getBrowser ());
-		this .url                  = new URI (window .location);
-		this .uninitializedNodes   = [ ];
-		this .uninitializedNodes2  = [ ];
-		this .namedNodes           = { };
-		this .importedNodes        = { };
-		this .protos               = new ProtoDeclarationArray ();
-		this .externprotos         = new ExternProtoDeclarationArray ();
-		this .routes               = new RouteArray ();
-		this .routeIndex           = { };
+		this .rootNodes_ .setAccessType (X3DConstants .initializeOnly);
+		this .rootNodes_ .addCloneCount (1);
+
+		this ._namedNodes     = new Map ();
+		this ._importedNodes  = new Map ();
+		this ._protos         = new ProtoDeclarationArray ();
+		this ._externprotos   = new ExternProtoDeclarationArray ();
+		this ._routes         = new RouteArray ();
+		this ._routeIndex     = new Map ();
+		this ._worldInfoNodes = [ ];
 	}
 
-	X3DExecutionContext .prototype = $.extend (Object .create (X3DBaseNode .prototype),
+	X3DExecutionContext .prototype = Object .assign (Object .create (X3DBaseNode .prototype),
 	{
 		constructor: X3DExecutionContext,
-		setup: function ()
-		{
-			X3DBaseNode .prototype .setup .call (this);
-
-			// Setup nodes
-
-			while (this .uninitializedNodes .length)
-			{
-				var uninitializedNodes = this .uninitializedNodes;
-
-				this .uninitializedNodes  = this .uninitializedNodes2;
-				this .uninitializedNodes2 = uninitializedNodes;
-	
-				for (var i = 0, length = uninitializedNodes .length; i < length; ++ i)
-					uninitializedNodes [i] .setup ();
-
-				uninitializedNodes .length = 0;
-			}
-		},
-		isMasterContext: function ()
+		isMainContext: function ()
 		{
 			return false;
 		},
@@ -135,78 +105,99 @@ function ($,
 		{
 			return false;
 		},
-		getSpecificationVersion: function ()
-		{
-			return this .specificationVersion;
-		},
-		setEncoding: function (value)
+		getPrototype: function ()
 		{
-			this .encoding = value;
+			const X3DProtoDeclaration = require ("x_ite/Prototype/X3DProtoDeclaration");
+
+			for (const node of this .getParents ())
+			{
+				if (node instanceof X3DProtoDeclaration)
+					return node;
+			}
+
+			return null;
 		},
-		getEncoding: function ()
+		getInstance: function ()
 		{
-			return this .encoding;
+			const X3DPrototypeInstance = require ("x_ite/Components/Core/X3DPrototypeInstance");
+
+			for (const node of this .getParents ())
+			{
+				if (node instanceof X3DPrototypeInstance)
+					return node;
+			}
+
+			return null;
 		},
-		getWorldURL: function ()
+		getSpecificationVersion: function ()
 		{
-			return this .getURL () .location;
+			return this .getExecutionContext () .getSpecificationVersion ();
 		},
-		setURL: function (url)
+		getEncoding: function ()
 		{
-			this .url = url;
+			return this .getExecutionContext () .getEncoding ();
 		},
-		getURL: function ()
+		getWorldURL: function ()
 		{
-			return this .url;
+			return this .getExecutionContext () .getWorldURL ();
 		},
-		setProfile: function (profile)
+		getProfile: function ()
 		{
-			this .profile = profile;
+			return this .getExecutionContext () .getProfile ();
 		},
-		getProfile: function (profile)
+		getComponents: function ()
 		{
-			return this .profile;
+			return this .getExecutionContext () .getComponents ();
 		},
-		addComponent: function (component)
+		fromUnit: function (category, value)
 		{
-			this .components .add (component .name, component);
+			return this .getExecutionContext () .fromUnit (category, value);
 		},
-		getComponents: function ()
+		toUnit: function (category, value)
 		{
-			return this .components;
+			return this .getExecutionContext () .toUnit (category, value);
 		},
 		getUnits: function ()
 		{
 			return this .getExecutionContext () .getUnits ();
 		},
-		createNode: function (typeName, setup)
+		createNode: function (typeName, setup = true)
 		{
-			var interfaceDeclaration = this .getBrowser () .supportedNodes [typeName];
+			if (setup === false)
+			{
+				const Type = this .getBrowser () .getSupportedNode (typeName);
 
-			if (! interfaceDeclaration)
-				throw new Error ("Unknown node type '" + typeName + "'.");
+				if (! Type)
+					return null;
 
-			var node = interfaceDeclaration .createInstance (this);
+				return new Type (this);
+			}
+			else
+			{
+				const Type = this .getBrowser () .getSupportedNode (typeName);
 
-			if (setup === false)
-				return node;
+				if (! Type)
+					throw new Error ("Unknown node type '" + typeName + "'.");
 
-			node .setup ();
+				const baseNode = new Type (this);
 
-			return new Fields .SFNode (node);
+				baseNode .setup ();
+
+				return SFNodeCache .add (baseNode);
+			}
 		},
-		createProto: function (name, setup)
+		createProto: function (name, setup = true)
 		{
-			var executionContext = this;
+			let executionContext = this;
 
 			for (;;)
 			{
-				var proto = executionContext .protos [name];
+				const proto = executionContext .protos .get (name);
 
 				if (proto)
 					return proto .createInstance (this, setup);
 
-				var externproto = executionContext .externprotos [name];
+				const externproto = executionContext .externprotos .get (name);
 
 				if (externproto)
 					return externproto .createInstance (this, setup);
@@ -217,15 +208,14 @@ function ($,
 				executionContext = executionContext .getExecutionContext ();
 			}
 
-			throw new Error ("Unknown proto or externproto type '" + name + "'.");
-		},
-		addUninitializedNode: function (node)
-		{
-			this .uninitializedNodes .push (node);
+			if (setup === false)
+				return null;
+			else
+				throw new Error ("Unknown proto or externproto type '" + name + "'.");
 		},
 		addNamedNode: function (name, node)
 		{
-			if (this .namedNodes [name] !== undefined)
+			if (this ._namedNodes .has (name))
 				throw new Error ("Couldn't add named node: node named '" + name + "' is already in use.");
 
 			this .updateNamedNode (name, node);
@@ -236,12 +226,13 @@ function ($,
 				throw new Error ("Couldn't update named node: node must be of type SFNode.");
 
 			name = String (name);
-			node = new Fields .SFNode (node instanceof Fields .SFNode ? node .getValue () : node);
 
-			if (! node .getValue ())
+			const baseNode = node instanceof Fields .SFNode ? node .getValue () : node;
+
+			if (! baseNode)
 				throw new Error ("Couldn't update named node: node IS NULL.");
 
-			if (node .getValue () .getExecutionContext () !== this)
+			if (baseNode .getExecutionContext () !== this)
 				throw new Error ("Couldn't update named node: node does not belong to this execution context.");
 
 			if (name .length === 0)
@@ -249,46 +240,50 @@ function ($,
 
 			// Remove named node.
 
-			this .removeNamedNode (node .getValue () .getName ());
+			this .removeNamedNode (baseNode .getName ());
 			this .removeNamedNode (name);
 
 			// Update named node.
 
-			node .getValue () .setName (name);
+			baseNode .setName (name);
 
-			this .namedNodes [name] = node;
+			this ._namedNodes .set (name, baseNode);
 		},
 		removeNamedNode: function (name)
 		{
-			delete this .namedNodes [name];
+			this ._namedNodes .delete (name);
 		},
 		getNamedNode: function (name)
 		{
-			var node = this .namedNodes [name];
+			const baseNode = this ._namedNodes .get (name);
 
-			if (! node)
-				throw new Error ("Named node '" + name + "' not found.");
+			if (baseNode)
+				return SFNodeCache .get (baseNode);
 
-			return node;
+			throw new Error ("Named node '" + name + "' not found.");
+		},
+		getNamedNodes: function ()
+		{
+			return this ._namedNodes;
 		},
 		getUniqueName: function (name)
 		{
-			var _TrailingNumbers = /(_\d+$)/;
+			const _TrailingNumbers = /(_\d+$)/;
 
 			name = name .replace (_TrailingNumbers, "");
 
-			var
+			let
 				newName = name,
 				i       = 64;
 
 			for (; i;)
 			{
-				if (this .namedNodes [newName] || newName .length === 0)
+				if (this ._namedNodes .has (newName) || newName .length === 0)
 				{
-					var
+					const
 						min = i,
 						max = i <<= 1;
-		
+
 					newName  = name;
 					newName += '_';
 					newName += Math .round (Algorithm .random (min, max));
@@ -296,7 +291,7 @@ function ($,
 				else
 					break;
 			}
-		
+
 			return newName;
 		},
 		addImportedNode: function (inlineNode, exportedName, importedName)
@@ -304,7 +299,7 @@ function ($,
 			if (importedName === undefined)
 				importedName = exportedName;
 
-			if (this .importedNodes [importedName])
+			if (this ._importedNodes .has (importedName))
 				throw new Error ("Couldn't add imported node: imported name '" + importedName + "' already in use.");
 
 			this .updateImportedNode (inlineNode, exportedName, importedName);
@@ -327,32 +322,39 @@ function ($,
 			if (importedName .length === 0)
 				throw new Error ("Couldn't update imported node: imported name is empty.");
 
+			// Update imported node.
+
 			this .removeImportedNode (importedName);
 
-			this .importedNodes [importedName] = new ImportedNode (this, inlineNode, exportedName, importedName);
-			this .importedNodes [importedName] .setup ();
+			const importedNode = new ImportedNode (this, inlineNode, exportedName, importedName);
+
+			this ._importedNodes .set (importedName, importedNode);
+
+			importedNode .setup ();
 		},
 		removeImportedNode: function (importedName)
 		{
-			var importedNode = this .importedNodes [importedName];
+			const importedNode = this ._importedNodes .get (importedName);
 
-			if (importedNode)
-				importedNode .dispose ();
+			if (! importedNode)
+				return;
 
-			delete this .importedNodes [importedName];
+			importedNode .dispose ();
+
+			this ._importedNodes .delete (importedName);
 		},
 		getImportedNode: function (importedName)
 		{
-			var importedNode = this .importedNodes [importedName];
+			const importedNode = this ._importedNodes .get (importedName);
 
 			if (importedNode)
-				return importedNode .getExportedNode ();
+				return importedNode .getExportedNode () .valueOf ();
 
 			throw new Error ("Imported node '" + importedName + "' not found.");
 		},
 		getImportedNodes: function ()
 		{
-			return this .importedNodes;
+			return this ._importedNodes;
 		},
 		getLocalNode: function (name)
 		{
@@ -362,14 +364,37 @@ function ($,
 			}
 			catch (error)
 			{
-				var importedNode = this .importedNodes [name];
+				const importedNode = this ._importedNodes .get (name);
 
 				if (importedNode)
-					return new Fields .SFNode (importedNode);
+					return SFNodeCache .get (importedNode);
 
 				throw new Error ("Unknown named or imported node '" + name + "'.");
 			}
 		},
+		getLocalName: function (node)
+		{
+			if (! (node instanceof Fields .SFNode))
+				throw new Error ("Couldn't get local name: node is NULL.");
+
+			if (node .getValue () .getExecutionContext () === this)
+				return node .getValue () .getName ();
+
+			for (const importedNode of this ._importedNodes .values ())
+			{
+				try
+				{
+					if (importedNode .getExportedNode () .getValue () === node .getValue ())
+						return importedNode .getImportedName ();
+				}
+				catch (error)
+				{
+					//console .log (error);
+				}
+			}
+
+			throw new Error ("Couldn't get local name: node is shared.");
+		},
 		setRootNodes: function () { },
 		getRootNodes: function ()
 		{
@@ -377,104 +402,222 @@ function ($,
 		},
 		getProtoDeclaration: function (name)
 		{
-			return this .protos .get (name);
+			const proto = this ._protos .get (name);
+
+			if (proto)
+				return proto;
+
+			throw new Error ("Proto declaration '" + name + "' not found.");
 		},
 		getProtoDeclarations: function ()
 		{
-			return this .protos;
+			return this ._protos;
 		},
 		getExternProtoDeclaration: function (name)
 		{
-			return this .externprotos .get (name);
+			const externproto = this ._externprotos .get (name);
+
+			if (externproto)
+				return externproto;
+
+			throw new Error ("Extern proto declaration '" + name + "' not found.");
 		},
 		getExternProtoDeclarations: function ()
 		{
-			return this .externprotos;
+			return this ._externprotos;
 		},
 		addRoute: function (sourceNode, sourceField, destinationNode, destinationField)
 		{
-			try
-			{
-				sourceField      = String (sourceField);
-				destinationField = String (destinationField);
+			sourceField      = String (sourceField);
+			destinationField = String (destinationField);
 
-				if (! (sourceNode instanceof Fields .SFNode))
-					throw new Error ("Bad ROUTE specification: source node must be of type SFNode.");
+			if (! (sourceNode instanceof Fields .SFNode))
+				throw new Error ("Bad ROUTE specification: source node must be of type SFNode.");
 
-				if (! (destinationNode instanceof Fields .SFNode))
-					throw new Error ("Bad ROUTE specification: destination node must be of type SFNode.");
+			if (! (destinationNode instanceof Fields .SFNode))
+				throw new Error ("Bad ROUTE specification: destination node must be of type SFNode.");
 
-				sourceNode      = sourceNode      .getValue ();
-				destinationNode = destinationNode .getValue ();
+			const
+				sourceNodeValue      = sourceNode      .getValue (),
+				destinationNodeValue = destinationNode .getValue ();
 
-				if (! sourceNode)
-					throw new Error ("Bad ROUTE specification: source node is NULL.");
+			if (! sourceNodeValue)
+				throw new Error ("Bad ROUTE specification: source node is NULL.");
 
-				if (! destinationNode)
-					throw new Error ("Bad ROUTE specification: destination node is NULL.");
+			if (! destinationNodeValue)
+				throw new Error ("Bad ROUTE specification: destination node is NULL.");
 
-				if (sourceNode instanceof ImportedNode || destinationNode instanceof ImportedNode)
-				{
-					if (sourceNode instanceof ImportedNode)
-						sourceNode .addRoute (sourceNode, sourceField, destinationNode, destinationField);
+			// Imported nodes handling.
 
-					if (destinationNode instanceof ImportedNode)
-						destinationNode .addRoute (sourceNode, sourceField, destinationNode, destinationField);
+			let
+				importedSourceNode      = sourceNodeValue      instanceof ImportedNode ? sourceNodeValue      : null,
+				importedDestinationNode = destinationNodeValue instanceof ImportedNode ? destinationNodeValue : null;
 
-					return;
-				}
+			try
+			{
+				// If sourceNode is shared node try to find the corresponding ImportedNode.
+				if (sourceNodeValue .getExecutionContext () !== this)
+					importedSourceNode = this .getLocalNode (this .getLocalName (sourceNode)) .getValue ();
+			}
+			catch (error)
+			{
+				// Source node is shared but not imported.
+			}
+
+			try
+			{
+				// If destinationNode is shared node try to find the corresponding ImportedNode.
+				if (destinationNodeValue .getExecutionContext () !== this)
+					importedDestinationNode = this .getLocalNode (this .getLocalName (destinationNode)) .getValue ();
+			}
+			catch (error)
+			{
+				// Destination node is shared but not imported.
+			}
+
+			if (importedSourceNode instanceof ImportedNode && importedDestinationNode instanceof ImportedNode)
+			{
+				importedSourceNode      .addRoute (importedSourceNode, sourceField, importedDestinationNode, destinationField);
+				importedDestinationNode .addRoute (importedSourceNode, sourceField, importedDestinationNode, destinationField);
+			}
+			else if (importedSourceNode instanceof ImportedNode)
+			{
+				importedSourceNode .addRoute (importedSourceNode, sourceField, destinationNodeValue, destinationField);
+			}
+			else if (importedDestinationNode instanceof ImportedNode)
+			{
+				importedDestinationNode .addRoute (sourceNodeValue, sourceField, importedDestinationNode, destinationField);
+			}
+
+			// If either sourceNode or destinationNode is an ImportedNode return here without value.
+			if (importedSourceNode === sourceNodeValue || importedDestinationNode === destinationNodeValue)
+				return;
+
+			// Create route and return.
+
+			return this .addSimpleRoute (sourceNodeValue, sourceField, destinationNodeValue, destinationField);
+		},
+		addSimpleRoute: function (sourceNode, sourceField, destinationNode, destinationField)
+		{
+			// Source and dest node are here X3DBaseNode.
+
+			try
+			{
+				// Private function.
+				// Create route and return.
 
 				sourceField      = sourceNode      .getField (sourceField),
 				destinationField = destinationNode .getField (destinationField);
 
 				if (! sourceField .isOutput ())
-					throw new Error ("Bad ROUTE specification: Field named '" + sourceField .getName () + "' in node named '" + sourceNode .getName () + "' of type " + sourceNode .getTypeName () + " is not an output field.");
+					throw new Error ("Field named '" + sourceField .getName () + "' in node named '" + sourceNode .getName () + "' of type " + sourceNode .getTypeName () + " is not an output field.");
 
 				if (! destinationField .isInput ())
-					throw new Error ("Bad ROUTE specification: Field named '" + destinationField .getName () + "' in node named '" + destinationNode .getName () + "' of type " + destinationNode .getTypeName () + " is not an input field.");
+					throw new Error ("Field named '" + destinationField .getName () + "' in node named '" + destinationNode .getName () + "' of type " + destinationNode .getTypeName () + " is not an input field.");
 
 				if (sourceField .getType () !== destinationField .getType ())
-					throw new Error ("Bad ROUTE specification: ROUTE types " + sourceField .getTypeName () + " and " + destinationField .getTypeName () + " do not match.");
+					throw new Error ("ROUTE types " + sourceField .getTypeName () + " and " + destinationField .getTypeName () + " do not match.");
 
-				var id = sourceField .getId () + "." + destinationField .getId ();
+				const id = sourceField .getId () + "." + destinationField .getId ();
 
-				if (this .routeIndex [id])
-					return this .routeIndex [id];
+				let route = this ._routeIndex .get (id);
 
-				var route = new X3DRoute (this, sourceNode, sourceField, destinationNode, destinationField);
+				if (route)
+					return route;
 
-				route .setup ();
+				route = new X3DRoute (this, sourceNode, sourceField, destinationNode, destinationField);
 
-				this .routes .getValue () .push (route);
-				this .routeIndex [id] = route;
+				this ._routes .getValue () .push (route);
+				this ._routeIndex .set (id, route);
 
 				return route;
 			}
 			catch (error)
 			{
-				throw new Error ("Bad ROUTE specification: " + error .message); 
+				throw new Error ("Bad ROUTE specification: " + error .message);
 			}
 		},
 		deleteRoute: function (route)
+		{
+			// sourceNode, sourceField, destinationNode, destinationField
+			if (arguments .length === 4)
+			{
+				route = this .getRoute .apply (this, arguments);
+
+				if (! route)
+					return false;
+			}
+
+			if (this .deleteSimpleRoute (route))
+				this .deleteImportedRoute (route .getSourceNode (), route .getDestinationNode (), route);
+		},
+		deleteSimpleRoute: function (route)
 		{
 			try
 			{
-				var
+				const
 					sourceField      = route ._sourceField,
 					destinationField = route ._destinationField,
 					id               = sourceField .getId () + "." + destinationField .getId (),
-					index            = this .routes .getValue () .indexOf (route);
+					index            = this ._routes .getValue () .indexOf (route);
 
 				route .disconnect ();
 
 				if (index !== -1)
-					this .routes .getValue () .splice (index, 1);
+					this ._routes .getValue () .splice (index, 1);
 
-				delete this .routeIndex [id];
+				this ._routeIndex .delete (id);
+
+				return true;
 			}
 			catch (error)
 			{
 				console .log (error);
+				return false;
+			}
+		},
+		deleteImportedRoute (sourceNode, destinationNode, route)
+		{
+			// Imported nodes handling.
+
+			let
+				importedSourceNode      = null,
+				importedDestinationNode = null;
+
+			try
+			{
+				// If sourceNode is shared node try to find the corresponding ImportedNode.
+				if (sourceNode .getValue () .getExecutionContext () !== this)
+					importedSourceNode = this .getLocalNode (this .getLocalName (sourceNode)) .getValue ();
+			}
+			catch (error)
+			{
+				// Source node is shared but not imported.
+			}
+
+			try
+			{
+				// If destinationNode is shared node try to find the corresponding ImportedNode.
+				if (destinationNode .getValue () .getExecutionContext () !== this)
+					importedDestinationNode = this .getLocalNode (this .getLocalName (destinationNode)) .getValue ();
+			}
+			catch (error)
+			{
+				// Destination node is shared but not imported.
+			}
+
+			if (importedSourceNode instanceof ImportedNode && importedDestinationNode instanceof ImportedNode)
+			{
+				importedSourceNode      .deleteRoute (route);
+				importedDestinationNode .deleteRoute (route);
+			}
+			else if (importedSourceNode instanceof ImportedNode)
+			{
+				importedSourceNode .deleteRoute (route);
+			}
+			else if (importedDestinationNode instanceof ImportedNode)
+			{
+				importedDestinationNode .deleteRoute (route);
 			}
 		},
 		getRoute: function (sourceNode, sourceField, destinationNode, destinationField)
@@ -485,47 +628,113 @@ function ($,
 			if (! destinationNode .getValue ())
 				throw new Error ("Bad ROUTE specification: destinationNode is NULL.");
 
-			var
-				sourceField      = sourceNode .getValue () .getField (sourceField),
-				destinationField = destinationNode .getValue () .getField (destinationField),
-				id               = sourceField .getId () + "." + destinationField .getId ();
+			sourceField      = sourceNode .getValue () .getField (sourceField);
+			destinationField = destinationNode .getValue () .getField (destinationField);
+
+			const id = sourceField .getId () + "." + destinationField .getId ();
 
-			return this .routeIndex [id];
+			return this ._routeIndex .get (id);
 		},
 		getRoutes: function ()
 		{
-			return this .routes;
+			return this ._routes;
 		},
-		changeViewpoint: function (name)
+		getWorldInfo: function ()
 		{
-			try
-			{
-				var
-					namedNode = this .getNamedNode (name),
-					viewpoint = X3DCast (X3DConstants .X3DViewpointNode, namedNode);
+			const length = this ._worldInfoNodes .length;
 
-				if (! viewpoint)
-					throw 1;
+			if (length)
+				return this ._worldInfoNodes [length - 1];
 
-				if (viewpoint .isBound_ .getValue ())
-					viewpoint .transitionStart (viewpoint);
+			return null;
+		},
+		addWorldInfo: function (worldInfoNode)
+		{
+			this ._worldInfoNodes .push (worldInfoNode);
+		},
+		removeWorldInfo: function (worldInfoNode)
+		{
+			this ._worldInfoNodes = this ._worldInfoNodes .filter (function (node) { return node !== worldInfoNode; });
+		},
+		toVRMLStream: function (stream)
+		{
+			const generator = Generator .Get (stream);
+
+			generator .PushExecutionContext (this);
+			generator .EnterScope ();
+			generator .ImportedNodes (this .getImportedNodes ());
+
+			// Output extern protos
+
+			this .getExternProtoDeclarations () .toVRMLStream (stream);
+
+			// Output protos
+
+			this .getProtoDeclarations () .toVRMLStream (stream);
+
+			// Output root nodes
 
+			const rootNodes = this .getRootNodes ();
+
+			for (let i = 0, length = rootNodes .length; i < length; ++ i)
+			{
+				const rootNode = rootNodes [i];
+
+				stream .string += generator .Indent ();
+
+				if (rootNode)
+					rootNode .toVRMLStream (stream);
 				else
-					viewpoint .set_bind_ = true;
+					stream .string += "NULL";
+
+				stream .string += "\n";
+
+				if (i !== length - 1)
+					stream .string += "\n";
 			}
-			catch (error)
+
+			// Output imported nodes
+
+			const importedNodes = this .getImportedNodes ();
+
+			if (importedNodes .size)
 			{
-				if (! this .isRootContext ())
-					this .getExecutionContext () .changeViewpoint (name);
-				else
-					throw new Error ("Viewpoint named '" + name + "' not found.");
+				stream .string += "\n";
+
+				importedNodes .forEach (function (importedNode)
+				{
+					try
+					{
+						importedNode .toVRMLStream (stream);
+
+						stream .string += "\n";
+					}
+					catch (error)
+					{ }
+				});
+			}
+
+			// Output routes
+
+			const routes = this .getRoutes ();
+
+			if (routes .length)
+			{
+				stream .string += "\n";
+
+				routes .toVRMLStream (stream);
 			}
+
+			generator .LeaveScope ();
+			generator .PopExecutionContext ();
 		},
 		toXMLStream: function (stream)
 		{
-			Generator .PushExecutionContext (this);
-			Generator. EnterScope ();
-			Generator .ImportedNodes (this .getImportedNodes ());
+			const generator = Generator .Get (stream);
+
+			generator .PushExecutionContext (this);
+			generator .EnterScope ();
+			generator .ImportedNodes (this .getImportedNodes ());
 
 			// Output extern protos
 
@@ -534,10 +743,10 @@ function ($,
 			// Output protos
 
 			this .getProtoDeclarations () .toXMLStream (stream);
-		
+
 			// Output root nodes
 
-			var rootNodes = this .getRootNodes ();
+			const rootNodes = this .getRootNodes ();
 
 			if (rootNodes .length)
 			{
@@ -545,32 +754,60 @@ function ($,
 
 				stream .string += "\n";
 			}
-		
+
 			// Output imported nodes
 
-			var importedNodes = this .getImportedNodes ();
+			const importedNodes = this .getImportedNodes ();
 
-			for (var importedName in importedNodes)
+			importedNodes .forEach (function (importedNode)
 			{
 				try
 				{
-					importedNodes [importedName] .toXMLStream (stream);
+					importedNode .toXMLStream (stream);
 
 					stream .string += "\n";
 				}
 				catch (error)
 				{ }
-			}
-		
+			});
+
 			// Output routes
 
 			this .getRoutes () .toXMLStream (stream);
 
-			Generator .LeaveScope ();
-			Generator .PopExecutionContext ();
+			generator .LeaveScope ();
+			generator .PopExecutionContext ();
 		},
 	});
 
+	Object .defineProperty (X3DExecutionContext .prototype, "specificationVersion",
+	{
+		get: function () { return this .getSpecificationVersion (); },
+		enumerable: true,
+		configurable: false
+	});
+
+	Object .defineProperty (X3DExecutionContext .prototype, "encoding",
+	{
+		get: function () { return this .getEncoding (); },
+		enumerable: true,
+		configurable: false
+	});
+
+	Object .defineProperty (X3DExecutionContext .prototype, "profile",
+	{
+		get: function () { return this .getProfile (); },
+		enumerable: true,
+		configurable: false
+	});
+
+	Object .defineProperty (X3DExecutionContext .prototype, "components",
+	{
+		get: function () { return this .getComponents (); },
+		enumerable: true,
+		configurable: false
+	});
+
 	Object .defineProperty (X3DExecutionContext .prototype, "worldURL",
 	{
 		get: function () { return this .getWorldURL (); },
@@ -593,5 +830,26 @@ function ($,
 		configurable: false
 	});
 
+	Object .defineProperty (X3DExecutionContext .prototype, "protos",
+	{
+		get: function () { return this .getProtoDeclarations (); },
+		enumerable: true,
+		configurable: false
+	});
+
+	Object .defineProperty (X3DExecutionContext .prototype, "externprotos",
+	{
+		get: function () { return this .getExternProtoDeclarations (); },
+		enumerable: true,
+		configurable: false
+	});
+
+	Object .defineProperty (X3DExecutionContext .prototype, "routes",
+	{
+		get: function () { return this .getRoutes (); },
+		enumerable: true,
+		configurable: false
+	});
+
 	return X3DExecutionContext;
 });