x_ite 4.2.17 → 4.7.7

package/src/x_ite/Execution/X3DExecutionContext.js

@@ -49,10 +49,7 @@
 
 define ([
 	"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",
@@ -60,15 +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,
           X3DBaseNode,
-          ComponentInfoArray,
           ImportedNode,
           ExternProtoDeclarationArray,
           ProtoDeclarationArray,
@@ -76,9 +70,9 @@ function (Fields,
           X3DRoute,
           X3DCast,
           X3DConstants,
-          URI,
-          Algorithm,
-          Generator)
+          Generator,
+          SFNodeCache,
+          Algorithm)
 {
 "use strict";
 
@@ -86,53 +80,24 @@ function (Fields,
 	{
 		X3DBaseNode .call (this, executionContext);
 
-		this .addChildObjects ("rootNodes", new Fields .MFNode ());
-
-		this .rootNodes_ .addClones (1);
-
-		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 .addChildObjects ("rootNodes",  new Fields .MFNode (),
+		                       "worldInfos", new Fields .MFNode ());
+
+		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 ();
 	}
 
 	X3DExecutionContext .prototype = Object .assign (Object .create (X3DBaseNode .prototype),
 	{
 		constructor: X3DExecutionContext,
-		setup: function ()
-		{
-			X3DBaseNode .prototype .setup .call (this);
-
-			var X3DProtoDeclaration = require ("x_ite/Prototype/X3DProtoDeclaration")
-
-			if (! (this instanceof X3DProtoDeclaration))
-			{
-				// 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;
 		},
@@ -140,78 +105,99 @@ function (Fields,
 		{
 			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 Type = this .getBrowser () .getSupportedNode (typeName);
+			if (setup === false)
+			{
+				const Type = this .getBrowser () .getSupportedNode (typeName);
+
+				if (! Type)
+					return null;
 
-			if (! Type)
-				throw new Error ("Unknown node type '" + typeName + "'.");
+				return new Type (this);
+			}
+			else
+			{
+				const Type = this .getBrowser () .getSupportedNode (typeName);
 
-			var node = new Type (this);
+				if (! Type)
+					throw new Error ("Unknown node type '" + typeName + "'.");
 
-			if (setup === false)
-				return node;
+				const baseNode = new Type (this);
 
-			node .setup ();
+				baseNode .setup ();
 
-			return new Fields .SFNode (node);
+				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);
@@ -222,15 +208,14 @@ function (Fields,
 				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);
@@ -241,12 +226,13 @@ function (Fields,
 				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)
@@ -254,46 +240,50 @@ function (Fields,
 
 			// 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));
@@ -301,7 +291,7 @@ function (Fields,
 				else
 					break;
 			}
-		
+
 			return newName;
 		},
 		addImportedNode: function (inlineNode, exportedName, importedName)
@@ -309,7 +299,7 @@ function (Fields,
 			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);
@@ -332,51 +322,39 @@ function (Fields,
 			if (importedName .length === 0)
 				throw new Error ("Couldn't update imported node: imported name is empty.");
 
-			// Update existing imported node.
+			// Update imported node.
 
-			for (var key in this .importedNodes)
-			{
-				var importedNode = this .importedNodes [key];
-				
-				if (importedNode .getInlineNode () === inlineNode && importedNode .getExportedName () === exportedName)
-				{
-					delete this .importedNodes [key];
-					
-					this .importedNodes [importedName] = importedNode;
-					
-					importedNode .setImportedName (importedName);
-					return;
-				}
-			}
+			this .removeImportedNode (importedName);
 
-			// Add new imported node.
+			const importedNode = new ImportedNode (this, inlineNode, exportedName, importedName);
 
-			this .removeImportedNode (importedName);
+			this ._importedNodes .set (importedName, importedNode);
 
-			this .importedNodes [importedName] = new ImportedNode (this, inlineNode, exportedName, importedName);
-			this .importedNodes [importedName] .setup ();
+			importedNode .setup ();
 		},
 		removeImportedNode: function (importedName)
 		{
-			var importedNode = this .importedNodes [importedName];
+			const importedNode = this ._importedNodes .get (importedName);
 
-			if (importedNode)
-				importedNode .dispose ();
+			if (! importedNode)
+				return;
+
+			importedNode .dispose ();
 
-			delete this .importedNodes [importedName];
+			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)
 		{
@@ -386,10 +364,10 @@ function (Fields,
 			}
 			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 + "'.");
 			}
@@ -398,21 +376,21 @@ function (Fields,
 		{
 			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 (var key in this .importedNodes)
+			for (const importedNode of this ._importedNodes .values ())
 			{
 				try
 				{
-					var importedNode = this .importedNodes [key];
-				
-					if (importedNode .getExportedNode () === node)
-						return key;
+					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.");
@@ -424,19 +402,29 @@ function (Fields,
 		},
 		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)
 		{
@@ -449,26 +437,27 @@ function (Fields,
 			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)
+			if (! sourceNodeValue)
 				throw new Error ("Bad ROUTE specification: source node is NULL.");
 
-			if (! destinationNode)
+			if (! destinationNodeValue)
 				throw new Error ("Bad ROUTE specification: destination node is NULL.");
 
 			// Imported nodes handling.
 
-			var
-				importedSourceNode      = sourceNode      instanceof ImportedNode ? sourceNode      : null,
-				importedDestinationNode = destinationNode instanceof ImportedNode ? destinationNode : null;
+			let
+				importedSourceNode      = sourceNodeValue      instanceof ImportedNode ? sourceNodeValue      : null,
+				importedDestinationNode = destinationNodeValue instanceof ImportedNode ? destinationNodeValue : null;
 
 			try
 			{
 				// If sourceNode is shared node try to find the corresponding ImportedNode.
-				if (sourceNode .getExecutionContext () !== this)
-					importedSourceNode = this .getLocalNode (this .getLocalName (sourceNode));
+				if (sourceNodeValue .getExecutionContext () !== this)
+					importedSourceNode = this .getLocalNode (this .getLocalName (sourceNode)) .getValue ();
 			}
 			catch (error)
 			{
@@ -478,30 +467,40 @@ function (Fields,
 			try
 			{
 				// If destinationNode is shared node try to find the corresponding ImportedNode.
-				if (destinationNode .getExecutionContext () !== this)
-					importedDestinationNode = this .getLocalNode (this .getLocalName (destinationNode));
+				if (destinationNodeValue .getExecutionContext () !== this)
+					importedDestinationNode = this .getLocalNode (this .getLocalName (destinationNode)) .getValue ();
 			}
 			catch (error)
 			{
 				// Destination node is shared but not imported.
 			}
 
-			if (importedSourceNode instanceof ImportedNode)
-				importedSourceNode .addRoute (importedSourceNode, sourceField, destinationNode, destinationField);
-
-			if (importedDestinationNode instanceof ImportedNode)
-				importedDestinationNode .addRoute (sourceNode, sourceField, importedDestinationNode, destinationField);
+			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 === sourceNode || importedDestinationNode === destinationNode)
+			if (importedSourceNode === sourceNodeValue || importedDestinationNode === destinationNodeValue)
 				return;
 
 			// Create route and return.
 
-			return this .addSimpleRoute (sourceNode, sourceField, destinationNode, destinationField);
+			return this .addSimpleRoute (sourceNodeValue, sourceField, destinationNodeValue, destinationField);
 		},
 		addSimpleRoute: function (sourceNode, sourceField, destinationNode, destinationField)
 		{
+			// Source and dest node are here X3DBaseNode.
+
 			try
 			{
 				// Private function.
@@ -519,54 +518,106 @@ function (Fields,
 				if (sourceField .getType () !== destinationField .getType ())
 					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)
 		{
-			try
+			// sourceNode, sourceField, destinationNode, destinationField
+			if (arguments .length === 4)
 			{
-				// sourceNode, sourceField, destinationNode, destinationField
-				if (arguments .length === 4)
-				{
-					route = this .getRoute .apply (this, arguments);
+				route = this .getRoute .apply (this, arguments);
 
-					if (! route)
-						return;
-				}
+				if (! route)
+					return false;
+			}
 
-				var
+			if (this .deleteSimpleRoute (route))
+				this .deleteImportedRoute (route .getSourceNode (), route .getDestinationNode (), route);
+		},
+		deleteSimpleRoute: function (route)
+		{
+			try
+			{
+				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);
+
+				this ._routeIndex .delete (id);
 
-				delete this .routeIndex [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)
@@ -577,47 +628,107 @@ function (Fields,
 			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)
+		getWorldInfos: function ()
 		{
-			try
-			{
-				var
-					namedNode = this .getNamedNode (name),
-					viewpoint = X3DCast (X3DConstants .X3DViewpointNode, namedNode);
+			return this .worldInfos_;
+		},
+		addWorldInfo: function (worldInfoNode)
+		{
+			this .worldInfos_ .push (worldInfoNode);
+		},
+		removeWorldInfo: function (worldInfoNode)
+		{
+			const index = this .worldInfos_ .getValue () .indexOf (worldInfoNode);
+
+			if (index !== -1)
+				this .worldInfos_ .splice (index, 1);
+		},
+		toVRMLStream: function (stream)
+		{
+			const generator = Generator .Get (stream);
 
-				if (! viewpoint)
-					throw 1;
+			generator .PushExecutionContext (this);
+			generator .EnterScope ();
+			generator .ImportedNodes (this .getImportedNodes ());
 
-				viewpoint .setAnimate (true); // VRML
+			// Output extern protos
 
-				if (viewpoint .isBound_ .getValue ())
-					viewpoint .transitionStart (viewpoint);
+			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)
 		{
-			var generator = Generator .Get (stream);
+			const generator = Generator .Get (stream);
 
 			generator .PushExecutionContext (this);
 			generator .EnterScope ();
@@ -630,10 +741,10 @@ function (Fields,
 			// Output protos
 
 			this .getProtoDeclarations () .toXMLStream (stream);
-		
+
 			// Output root nodes
 
-			var rootNodes = this .getRootNodes ();
+			const rootNodes = this .getRootNodes ();
 
 			if (rootNodes .length)
 			{
@@ -641,23 +752,23 @@ function (Fields,
 
 				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);
@@ -667,6 +778,34 @@ function (Fields,
 		},
 	});
 
+	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 (); },
@@ -689,5 +828,26 @@ function (Fields,
 		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;
 });