x_ite 4.0.5 → 4.7.5

package/src/x_ite/Execution/X3DScene.js

@@ -48,23 +48,25 @@
 
 
 define ([
-	"jquery",
 	"x_ite/Fields",
 	"x_ite/Execution/X3DExecutionContext",
+	"x_ite/Configuration/ComponentInfoArray",
 	"x_ite/Configuration/UnitInfo",
 	"x_ite/Configuration/UnitInfoArray",
 	"x_ite/Execution/ExportedNode",
 	"x_ite/Bits/X3DConstants",
 	"x_ite/InputOutput/Generator",
+	"x_ite/Fields/SFNodeCache",
 ],
-function ($,
-          Fields,
+function (Fields,
           X3DExecutionContext,
+          ComponentInfoArray,
           UnitInfo,
           UnitInfoArray,
           ExportedNode,
           X3DConstants,
-          Generator)
+          Generator,
+          SFNodeCache)
 {
 "use strict";
 
@@ -74,23 +76,30 @@ function ($,
 
 		this .getRootNodes () .setAccessType (X3DConstants .inputOutput);
 
-		this .unitArray = new UnitInfoArray ();
+		this ._specificationVersion = "3.3";
+		this ._encoding             = "SCRIPTED";
+		this ._profile              = null;
+		this ._components           = new ComponentInfoArray ([ ]);
+		this ._worldURL             = location .toString ();
+		this ._units                = new UnitInfoArray ();
 
-		this .unitArray .add ("angle",  new UnitInfo ("angle",  "radian",   1));
-		this .unitArray .add ("force",  new UnitInfo ("force",  "newton",   1));
-		this .unitArray .add ("length", new UnitInfo ("length", "metre",    1));
-		this .unitArray .add ("mass",   new UnitInfo ("mass",   "kilogram", 1));
+		this ._units .add ("angle",  new UnitInfo ("angle",  "radian",   1));
+		this ._units .add ("force",  new UnitInfo ("force",  "newton",   1));
+		this ._units .add ("length", new UnitInfo ("length", "metre",    1));
+		this ._units .add ("mass",   new UnitInfo ("mass",   "kilogram", 1));
 
-		this .metadata      = { };
-		this .exportedNodes = { };
+		this ._metadata      = new Map ();
+		this ._exportedNodes = new Map ();
+
+		this .rootNodes_ .setAccessType (X3DConstants .inputOutput);
 
 		this .setLive (false);
 	}
 
-	X3DScene .prototype = $.extend (Object .create (X3DExecutionContext .prototype),
+	X3DScene .prototype = Object .assign (Object .create (X3DExecutionContext .prototype),
 	{
 		constructor: X3DScene,
-		isMasterContext: function ()
+		isMainContext: function ()
 		{
 			return this === this .getExecutionContext ();
 		},
@@ -100,14 +109,56 @@ function ($,
 		},
 		getScene: function ()
 		{
-			if (this .isMasterContext ())
+			if (this .isMainContext ())
 				return this;
 
 			return this .getExecutionContext () .getScene ();
 		},
+		setSpecificationVersion: function (specificationVersion)
+		{
+			this ._specificationVersion = specificationVersion;
+		},
+		getSpecificationVersion: function ()
+		{
+			return this ._specificationVersion;
+		},
+		setEncoding: function (encoding)
+		{
+			this ._encoding = encoding;
+		},
+		getEncoding: function ()
+		{
+			return this ._encoding;
+		},
+		setWorldURL: function (url)
+		{
+			this ._worldURL = url;
+		},
+		getWorldURL: function ()
+		{
+			return this ._worldURL;
+		},
+		setProfile: function (profile)
+		{
+			this ._profile = profile;
+		},
+		getProfile: function ()
+		{
+			return this ._profile;
+		},
+		addComponent: function (component)
+		{
+			this ._components .add (component .name, component);
+		},
+		getComponents: function ()
+		{
+			return this ._components;
+		},
 		updateUnit: function (category, name, conversionFactor)
 		{
-			var unit = this .unitArray .get (category);
+			// Private function.
+
+			const unit = this ._units .get (category);
 
 			if (! unit)
 				return;
@@ -117,30 +168,86 @@ function ($,
 		},
 		getUnits: function ()
 		{
-			return this .unitArray;
+			return this ._units;
+		},
+		fromUnit: function (category, value)
+		{
+			switch (category)
+			{
+				// Base units
+
+			   case "angle":
+			   case "force":
+			   case "length":
+			   case "mass":
+					return value * this .getUnits () .get (category) .conversionFactor;
+
+				// Derived units
+
+				case "acceleration:":
+					return value * this .getUnits () .get ("length") .conversionFactor;
+				case "angularRate":
+					return value * this .getUnits () .get ("angle") .conversionFactor;
+				case "area":
+					return value * Math .pow (this .getUnits () .get ("length") .conversionFactor, 2);
+				case "speed":
+					return value * this .getUnits () .get ("length") .conversionFactor;
+				case "volume":
+					return value * Math .pow (this .getUnits () .get ("length") .conversionFactor, 3);
+			}
+
+			return value;
+		},
+		toUnit: function (category, value)
+		{
+			switch (category)
+			{
+				// Base units
+
+			   case "angle":
+			   case "force":
+			   case "length":
+			   case "mass":
+					return value / this .getUnits () .get (category) .conversionFactor;
+
+				// Derived units
+
+				case "acceleration:":
+					return value / this .getUnits () .get ("length") .conversionFactor;
+				case "angularRate":
+					return value / this .getUnits () .get ("angle") .conversionFactor;
+				case "area":
+					return value / Math .pow (this .getUnits () .get ("length") .conversionFactor, 2);
+				case "speed":
+					return value / this .getUnits () .get ("length") .conversionFactor;
+				case "volume":
+					return value / Math .pow (this .getUnits () .get ("length") .conversionFactor, 3);
+			}
+
+			return value;
 		},
 		setMetaData: function (name, value)
 		{
 			if (! name .length)
 				return;
 
-			this .metadata [name] = String (value);
+			this ._metadata .set (name, String (value));
 		},
 		removeMetaData: function (name)
 		{
-			delete this .metadata [name];
+			this ._metadata .delete (name);
 		},
 		getMetaData: function (name)
 		{
-			return this .metadata [name];
+			return this ._metadata .get (name);
 		},
-		getMetadata: function ()
+		getMetaDatas: function ()
 		{
-			return $.extend ({ }, this .metadata);
+			return this ._metadata;
 		},
 		addExportedNode: function (exportedName, node)
 		{
-			if (this .exportedNodes [exportedName])
+			if (this ._exportedNodes .has (exportedName))
 				throw new Error ("Couldn't add exported node: exported name '" + exportedName + "' already in use.");
 
 			this .updateExportedNode (exportedName, node);
@@ -161,41 +268,54 @@ function ($,
 			//if (node .getValue () .getExecutionContext () !== this)
 			//	throw new Error ("Couldn't update exported node: node does not belong to this execution context.");
 
-			this .exportedNodes [exportedName] = new ExportedNode (exportedName, node .getValue ());
+			const exportedNode = new ExportedNode (exportedName, node .getValue ());
+
+			this ._exportedNodes .set (exportedName, exportedNode);
 		},
 		removeExportedNode: function (exportedName)
 		{
-			delete this .exportedNodes [exportedName];
+			this ._exportedNodes .delete (exportedName);
 		},
 		getExportedNode: function (exportedName)
 		{
-			var exportedNode = this .exportedNodes [exportedName];
+			const exportedNode = this ._exportedNodes .get (exportedName);
 
 			if (exportedNode)
-				return exportedNode .getLocalNode ();	
+				return SFNodeCache .get (exportedNode .getLocalNode ());
 
 			throw new Error ("Exported node '" + exportedName + "' not found.");
 		},
 		getExportedNodes: function ()
 		{
-			return this .exportedNodes;
+			return this ._exportedNodes;
 		},
 		addRootNode: function (node)
 		{
-			if (! (node instanceof Fields .SFNode || node === null))
+			if (node === null)
+				node = new Fields .SFNode ();
+
+			if (! (node instanceof Fields .SFNode))
 				throw new Error ("Couldn't add root node: node must be of type SFNode.");
 
-			//if (node && node .getValue () && node .getValue () .getExecutionContext () !== this)
-			//	throw new Error ("Couldn't add root node: node does not belong to this execution context.");
+			const rootNodes = this .getRootNodes ();
+
+			for (let i = 0, length = rootNodes .length; i < length; ++ i)
+			{
+				if (rootNodes [i] .equals (node))
+					return;
+			}
 
-			this .getRootNodes () .push (node);
+			rootNodes .push (node);
 		},
 		removeRootNode: function (node)
 		{
-			if (! (node instanceof Fields .SFNode || node === null))
+			if (node === null)
+				node = new Fields .SFNode ();
+
+			if (! (node instanceof Fields .SFNode))
 				throw new Error ("Couldn't remove root node: node must be of type SFNode.");
 
-			var
+			const
 				rootNodes = this .getRootNodes (),
 				length    = rootNodes .length;
 
@@ -205,20 +325,133 @@ function ($,
 		{
 			this .getRootNodes () .setValue (value);
 		},
+		toStream: function (stream)
+		{
+			stream .string += Object .prototype .toString .call (this);
+		},
+		toVRMLStream: function (stream)
+		{
+			const generator = Generator .Get (stream);
+
+			let specificationVersion = this .getSpecificationVersion ();
+
+			if (specificationVersion === "2.0")
+				specificationVersion = "3.3";
+
+			stream .string += "#X3D V";
+			stream .string += specificationVersion;
+			stream .string += " ";
+			stream .string += "utf8";
+			stream .string += " ";
+			stream .string += this .getBrowser () .name;
+			stream .string += " ";
+			stream .string += "V";
+			stream .string += this .getBrowser () .version;
+			stream .string += "\n";
+			stream .string += "\n";
+
+			const profile = this .getProfile ();
+
+			if (profile)
+			{
+				profile .toVRMLStream (stream);
+
+				stream .string += "\n";
+				stream .string += "\n";
+			}
+
+			const components = this .getComponents ();
+
+			if (components .length)
+			{
+				components .toVRMLStream (stream);
+
+				stream .string += "\n";
+			}
+
+			// Units
+			{
+				let empty = true;
+
+				for (const unit of this .getUnits ())
+				{
+					if (unit .conversionFactor !== 1)
+					{
+						empty = false;
+
+						unit .toVRMLStream (stream);
+
+						stream .string += "\n";
+					}
+				}
+
+				if (! empty)
+					stream .string += "\n";
+			}
+
+			const metadata = this .getMetaDatas ();
+
+			if (metadata .size)
+			{
+				metadata .forEach (function (value, key)
+				{
+					stream .string += "META";
+					stream .string += " ";
+					stream .string += new Fields .SFString (key) .toString ();
+					stream .string += " ";
+					stream .string += new Fields .SFString (value) .toString ();
+					stream .string += "\n";
+				});
+
+				stream .string += "\n";
+			}
+
+			const exportedNodes = this .getExportedNodes ();
+
+			generator .PushExecutionContext (this);
+			generator .EnterScope ();
+			generator .ExportedNodes (exportedNodes);
+
+			X3DExecutionContext .prototype .toVRMLStream .call (this, stream);
+
+			if (exportedNodes .size)
+			{
+				stream .string += "\n";
+
+				exportedNodes .forEach (function (exportedNode)
+				{
+					try
+					{
+						exportedNode .toVRMLStream (stream);
+
+						stream .string += "\n";
+					}
+					catch (error)
+					{
+						console .log (error);
+					}
+				});
+			}
+
+			generator .LeaveScope ();
+			generator .PopExecutionContext ();
+		},
 		toXMLStream: function (stream)
 		{
-			var specificationVersion = this .getSpecificationVersion ();
+			const generator = Generator .Get (stream);
+
+			let specificationVersion = this .getSpecificationVersion ();
 
 			if (specificationVersion === "2.0")
 				specificationVersion = "3.3";
-		
+
 			stream .string += "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
 			stream .string += "<!DOCTYPE X3D PUBLIC \"ISO//Web3D//DTD X3D ";
 			stream .string += specificationVersion;
 			stream .string += "//EN\" \"http://www.web3d.org/specifications/x3d-";
 			stream .string += specificationVersion;
 			stream .string += ".dtd\">\n";
-		
+
 			stream .string += "<X3D";
 			stream .string += " ";
 			stream .string += "profile='";
@@ -235,23 +468,19 @@ function ($,
 			stream .string += specificationVersion;
 			stream .string += ".xsd'>\n";
 
-			Generator .IncIndent ();
+			generator .IncIndent ();
 
-			stream .string += Generator .Indent ();
+			stream .string += generator .Indent ();
 			stream .string += "<head>\n";
 
-			Generator .IncIndent ();
-		
+			generator .IncIndent ();
+
 			// <head>
 
 			this .getComponents () .toXMLStream (stream);
 
-			var units = this .getUnits ();
-
-			for (var i = 0, length = units .length; i < length; ++ i)
+			for (const unit of this .getUnits ())
 			{
-				var unit = units [i];
-
 				if (unit .conversionFactor !== 1)
 				{
 					unit .toXMLStream (stream);
@@ -259,68 +488,68 @@ function ($,
 					stream .string += "\n";
 				}
 			}
-		
-			var metaDatas = this .metadata;
 
-			for (var key in metaDatas)
+			this .getMetaDatas () .forEach (function (value, key)
 			{
-				stream .string += Generator .Indent ();
+				stream .string += generator .Indent ();
 				stream .string += "<meta";
 				stream .string += " ";
 				stream .string += "name='";
-				stream .string += Generator .XMLEncode (key);
+				stream .string += generator .XMLEncode (key);
 				stream .string += "'";
 				stream .string += " ";
 				stream .string += "content='";
-				stream .string += Generator .XMLEncode (metaDatas [key]);
+				stream .string += generator .XMLEncode (value);
 				stream .string += "'";
 				stream .string += "/>\n";
-			}
-		
+			});
+
 			// </head>
 
-			Generator .DecIndent ();
+			generator .DecIndent ();
 
-			stream .string += Generator .Indent ();
+			stream .string += generator .Indent ();
 			stream .string += "</head>\n";
-			stream .string += Generator .Indent ();
+			stream .string += generator .Indent ();
 			stream .string += "<Scene>\n";
 
-			Generator .IncIndent ();
-		
+			generator .IncIndent ();
+
 			// <Scene>
 
-			var exportedNodes = this .getExportedNodes ();
+			const exportedNodes = this .getExportedNodes ();
 
-			Generator .PushExecutionContext (this);
-			Generator .EnterScope ();
-			Generator .ExportedNodes (exportedNodes);
+			generator .PushExecutionContext (this);
+			generator .EnterScope ();
+			generator .ExportedNodes (exportedNodes);
 
 			X3DExecutionContext .prototype .toXMLStream .call (this, stream);
-		
-			for (var exportedName in exportedNodes)
+
+			exportedNodes .forEach (function (exportedNode)
 			{
-				//try
+				try
 				{
-					exportedNodes [exportedName] .toXMLStream (stream);
+					exportedNode .toXMLStream (stream);
 
 					stream .string += "\n";
 				}
-				//catch (const X3DError &)
-				{ }
-			}
+				catch (error)
+				{
+					console .log (error);
+				}
+			});
 
-			Generator .LeaveScope ();
-			Generator .PopExecutionContext ();
+			generator .LeaveScope ();
+			generator .PopExecutionContext ();
 
 			// </Scene>
 
-			Generator .DecIndent ();
+			generator .DecIndent ();
 
-			stream .string += Generator .Indent ();
+			stream .string += generator .Indent ();
 			stream .string += "</Scene>\n";
 
-			Generator .DecIndent ();
+			generator .DecIndent ();
 
 			stream .string += "</X3D>\n";
 		},

package/src/x_ite/{Error.js → Fallback.js}

@@ -56,38 +56,39 @@ function ($)
 
 	// Everything went wrong when the Error function is called.
 
-	function Error (error, fallbacks)
+	const Fallback =
 	{
-		$(function ()
+		error: function (error, fallbacks)
 		{
-		   var elements = $("X3DCanvas");
-
-			elements .each (function ()
+			$(function ()
 			{
-				Error .fallback ($(this));
-			});
+				const elements = $("X3DCanvas");
 
-			for (var i = 0; i < fallbacks .length; ++ i)
-			{
-			   var fallback = fallbacks [i];
+				this .show (elements, error);
 
-				if (typeof fallback === "function")
-				   fallback (elements, error);
+				for (const fallback of fallbacks)
+				{
+					if (typeof fallback === "function")
+						fallback (elements, error);
+				}
 			}
-		});
-	}
+			.bind (this));
+		},
+		show: function (elements, error)
+		{
+			console .log (error);
 
-	// In some browser went something wrong when the fallback function is called.
+			const consoleElement = $(".x_ite-console");
 
-	function fallback (elements)
-	{
-		elements .addClass ("x_ite-browser-fallback");
-		elements .children (".x_ite-private-browser") .hide ();
-		elements .children (":not(.x_ite-private-browser)") .addClass ("x_ite-fallback");
-		elements .children (":not(.x_ite-private-browser)") .show ();
-	}
+			if (consoleElement .length)
+				consoleElement .append (document .createTextNode (error));
 
-	Error .fallback = fallback;
+			elements .addClass ("x_ite-browser-fallback");
+			elements .children (".x_ite-private-browser") .hide ();
+			elements .children (":not(.x_ite-private-browser)") .addClass ("x_ite-fallback");
+			elements .children (":not(.x_ite-private-browser)") .show ();
+		},
+	};
 
-	return Error;
+	return Fallback;
 });