x_ite 4.2.17 → 4.7.7

package/src/x_ite/Components/Core/X3DPrototypeInstance.js

@@ -48,17 +48,13 @@
 
 
 define ([
-	"x_ite/Basic/FieldDefinitionArray",
-	"x_ite/Fields",
 	"x_ite/Base/X3DChildObject",
 	"x_ite/Components/Core/X3DNode",
 	"x_ite/Execution/X3DExecutionContext",
 	"x_ite/Bits/X3DConstants",
 	"x_ite/InputOutput/Generator",
 ],
-function (FieldDefinitionArray,
-          Fields,
-          X3DChildObject,
+function (X3DChildObject,
           X3DNode,
           X3DExecutionContext,
           X3DConstants,
@@ -69,25 +65,22 @@ function (FieldDefinitionArray,
 	function X3DPrototypeInstance (executionContext, protoNode)
 	{
 		this .protoNode        = protoNode;
-		this .fieldDefinitions = new FieldDefinitionArray (protoNode .getFieldDefinitions () .getValue () .slice ());
+		this .fieldDefinitions = protoNode .getFieldDefinitions ();
 
-		X3DNode             .call (this, executionContext);
-		X3DExecutionContext .call (this, executionContext);
+		X3DNode .call (this, executionContext);
 
 		this .addType (X3DConstants .X3DPrototypeInstance);
-		this .getRootNodes () .setAccessType (X3DConstants .initializeOnly);
 
-		this .getScene () .addInitLoadCount (this);
+		if (executionContext .getPrototype ())
+			return;
 
-		if (protoNode .isExternProto)
-			protoNode .requestAsyncLoad (this .construct .bind (this));
+		if (! protoNode .isExternProto)
+			return;
 
-		else
-			this .construct ();
+		protoNode .requestImmediateLoad (this .construct .bind (this));
 	}
 
-	X3DPrototypeInstance .prototype = Object .assign (Object .create (X3DExecutionContext .prototype),
-		X3DNode .prototype,
+	X3DPrototypeInstance .prototype = Object .assign (Object .create (X3DNode .prototype),
 	{
 		constructor: X3DPrototypeInstance,
 		create: function (executionContext)
@@ -108,196 +101,171 @@ function (FieldDefinitionArray,
 		},
 		construct: function ()
 		{
-			this .getScene () .removeInitLoadCount (this);
+			const proto = this .protoNode .getProtoDeclaration ();
 
-			var proto = this .protoNode .getProtoDeclaration ();
-
-			if (proto)
+			if (!proto)
 			{
-				// If there is a proto the externproto is completely loaded.
-			
-				if (! this .metadata_ .getSet ())
-					this .metadata_ = proto .metadata_;
+				this .body = new X3DExecutionContext (this .getExecutionContext ());
+				this .body .addParent (this);
+				this .body .setup ();
 
-				if (this .protoNode .isExternProto)
-				{
-					var fieldDefinitions = proto .getFieldDefinitions ();
+				if (this .isInitialized ())
+					X3DChildObject .prototype .addEvent .call (this);
+
+				return;
+			}
+
+			// If there is a proto the externproto is completely loaded.
 
-					for (var i = 0, length = fieldDefinitions .length; i < length; ++ i)
+			if (this .protoNode .isExternProto)
+			{
+				for (const fieldDefinition of proto .getFieldDefinitions ())
+				{
+					try
 					{
-						try
-						{
-							var
-								fieldDefinition = fieldDefinitions [i],
-                        field           = this .getField (fieldDefinition .name),
-								protoField      = proto .getField (fieldDefinition .name);
+						const
+							field      = this .getField (fieldDefinition .name),
+							protoField = proto .getField (fieldDefinition .name);
 
-							// Continue if something is wrong.
-							if (field .getAccessType () !== protoField .getAccessType ())
-								continue;
+						// Continue if something is wrong.
+						if (field .getAccessType () !== protoField .getAccessType ())
+							continue;
 
-							// Continue if something is wrong.
-							if (field .getType () !== protoField .getType ())
-								continue;
+						// Continue if something is wrong.
+						if (field .getType () !== protoField .getType ())
+							continue;
 
-							// Continue if field is eventIn or eventOut.
-							if (! (field .getAccessType () & X3DConstants .initializeOnly))
-								continue;
+						// Continue if field is eventIn or eventOut.
+						if (! (field .getAccessType () & X3DConstants .initializeOnly))
+							continue;
 
-							// Is set during parse.	
-							if (field .getSet ())
-								continue;
+						// Is set during parse.
+						if (field .getModificationTime ())
+							continue;
 
-							// Has IS references.
-							if (field .hasReferences ())
-								continue;
+						// Has IS references.
+						if (field .hasReferences ())
+							continue;
 
-							if (field .equals (protoField))
-								continue;
+						if (field .equals (protoField))
+							continue;
 
-							// If default value of protoField is different from field update default value for field.
-							field .setValue (protoField);
-						}
-						catch (error)
-						{
-							// Definition exists in proto but does not exist in extern proto.
-							this .addField (fieldDefinition);
-						}
+						// If default value of protoField is different from field update default value for field.
+						field .setValue (protoField);
+					}
+					catch (error)
+					{
+						// Definition exists in proto but does not exist in extern proto.
+						this .addField (fieldDefinition);
 					}
 				}
+			}
 
-				// Assign metadata.
+			// Create execution context.
 
-				this .setURL (proto .getURL ());
+			this .body = new X3DExecutionContext (proto .getExecutionContext ());
+			this .body .addParent (this);
 
-				this .importExternProtos (proto .externprotos);
-				this .importProtos       (proto .protos);
-				this .copyRootNodes      (proto .rootNodes);
+			// Copy proto.
 
-				if (this .isInitialized ())
-				{
-					this .setInitialized (false);
-					this .setup ();
-					this .setTainted (false);
-					X3DChildObject .prototype .addEvent .call (this);
-				}
-			}
-		},
-		setup: function ()
-		{
-			X3DNode             .prototype .setup .call (this);
-			X3DExecutionContext .prototype .setup .call (this);
+			this .importExternProtos (proto .getBody () .externprotos);
+			this .importProtos       (proto .getBody () .protos);
+			this .copyRootNodes      (proto .getBody () .rootNodes);
+			this .copyImportedNodes  (proto .getBody (), proto .getBody () .getImportedNodes ());
+			this .copyRoutes         (proto .getBody (), proto .getBody () .routes);
+
+			this .body .setup ();
+
+			if (this .isInitialized ())
+				X3DChildObject .prototype .addEvent .call (this);
 		},
 		initialize: function ()
 		{
 			try
 			{
-				var proto = this .protoNode .getProtoDeclaration ();
-
-				if (proto)
-				{
-					this .copyImportedNodes (proto, proto .importedNodes);
-					this .copyRoutes (proto, proto .routes);
-				}
+				X3DNode .prototype .initialize .call (this);
 
-				// TODO: connect getRootNodes () to X3DChildObject .prototype .addEvent .call (this);
-
-				// Now initialize bases.
-	
-				X3DNode             .prototype .initialize .call (this);
-				X3DExecutionContext .prototype .initialize .call (this);
+				if (! this .protoNode .isExternProto)
+					this .construct ();
 			}
 			catch (error)
 			{
 				console .error (error .message);
 			}
 		},
-		getSpecificationVersion: function ()
+		getExtendedEventHandling: function ()
 		{
-			return this .getExecutionContext () .getSpecificationVersion ();
+			return false;
 		},
-		getEncoding: function ()
+		getBody: function ()
 		{
-			return this .getExecutionContext () .getEncoding ();
+			return this .body;
 		},
 		getInnerNode: function ()
 		{
-			var rootNodes = this .getRootNodes () .getValue ();
-			
+			const rootNodes = this .body .getRootNodes () .getValue ();
+
 			if (rootNodes .length)
 			{
-				var rootNode = rootNodes [0];
-				
+				const rootNode = rootNodes [0];
+
 				if (rootNode)
 					return rootNode .getValue () .getInnerNode ();
 			}
 
 			throw new Error ("Root node not available.");
 		},
-		fromUnit: function (category, value)
-		{
-			return this .protoNode .getProtoDeclaration () .fromUnit (category, value);
-		},
-		toUnit: function (category, value)
+		importExternProtos: function (externprotos1)
 		{
-			return this .protoNode .getProtoDeclaration () .toUnit (category, value);
-		},
-		getExtendedEventHandling: function ()
-		{
-			return false;
-		},
-		importExternProtos: function (externprotos)
-		{
-			for (var i = 0, length = externprotos .length; i < length; ++ i)
-				this .externprotos .add (externprotos [i] .getName (), externprotos [i]);
+			const externprotos2 = this .body .externprotos;
+
+			for (const externproto of externprotos1)
+				externprotos2 .add (externproto .getName (), externproto);
 		},
-		importProtos: function (protos)
+		importProtos: function (protos1)
 		{
-			for (var i = 0, length = protos .length; i < length; ++ i)
-				this .protos .add (protos [i] .getName (), protos [i]);
+			const protos2 = this .body .protos;
+
+			for (const proto of protos1)
+				protos2 .add (proto .getName (), proto);
 		},
 		copyRootNodes: function (rootNodes1)
 		{
-			var rootNodes2 = this .getRootNodes ();
+			const rootNodes2 = this .body .getRootNodes ();
 
-			for (var i = 0, length = rootNodes1 .length; i < length; ++ i)
-			{
-				rootNodes2 .push (rootNodes1 [i] .copy (this));
-			}
+			for (const node of rootNodes1)
+				rootNodes2 .push (node .copy (this));
 		},
 		copyImportedNodes: function (executionContext, importedNodes)
 		{
-			for (var importedName in importedNodes)
+			importedNodes .forEach (function (importedNode, importedName)
 			{
 				try
 				{
-					var
-						importedNode = importedNodes [importedName],
-						inlineNode   = this .getNamedNode (importedNode .getInlineNode () .getName ()),
-						exportedName = importedNode .getExportedName (),
-						importedName = importedNode .getImportedName ();
+					const
+						inlineNode   = this .body .getNamedNode (importedNode .getInlineNode () .getName ()),
+						exportedName = importedNode .getExportedName ();
 
-					this .addImportedNode (inlineNode, exportedName, importedName);
+					this .body .addImportedNode (inlineNode, exportedName, importedName);
 				}
 				catch (error)
 				{
 					console .error ("Bad IMPORT specification in copy: ", error);
 				}
-			}
+			},
+			this);
 		},
 		copyRoutes: function (executionContext, routes)
 		{
-			for (var i = 0, length = routes .length; i < length; ++ i)
+			for (const route of routes)
 			{
 				try
 				{
-					var
-						route           = routes [i],
-						sourceNode      = this .getLocalNode (executionContext .getLocalName (route .sourceNode)),
-						destinationNode = this .getLocalNode (executionContext .getLocalName (route .destinationNode));
+					const
+						sourceNode      = this .body .getLocalNode (executionContext .getLocalName (route .sourceNode)),
+						destinationNode = this .body .getLocalNode (executionContext .getLocalName (route .destinationNode));
 
-					// new Route ... addUninitializedNode ...
-					this .addRoute (sourceNode, route .sourceField, destinationNode, route .destinationField);
+					this .body .addRoute (sourceNode, route .sourceField, destinationNode, route .destinationField);
 				}
 				catch (error)
 				{
@@ -307,18 +275,18 @@ function (FieldDefinitionArray,
 		},
 		toXMLStream: function (stream)
 		{
-			var generator = Generator .Get (stream);
+			const generator = Generator .Get (stream);
 
 			if (generator .IsSharedNode (this))
 			{
 				stream .string += generator .Indent ();
-				stream .string += "<!-- NULL -->";		
+				stream .string += "<!-- NULL -->";
 				return;
 			}
 
 			generator .EnterScope ();
 
-			var name = generator .Name (this);
+			const name = generator .Name (this);
 
 			if (name .length)
 			{
@@ -335,7 +303,7 @@ function (FieldDefinitionArray,
 					stream .string += generator .XMLEncode (name);
 					stream .string += "'";
 
-					var containerField = generator .ContainerField ();
+					const containerField = generator .ContainerField ();
 
 					if (containerField)
 					{
@@ -372,7 +340,7 @@ function (FieldDefinitionArray,
 				stream .string += "'";
 			}
 
-			var containerField = generator .ContainerField ();
+			const containerField = generator .ContainerField ();
 
 			if (containerField)
 			{
@@ -384,8 +352,8 @@ function (FieldDefinitionArray,
 					stream .string += "'";
 				}
 			}
-		
-			var fields = this .getChangedFields ();
+
+			const fields = this .getChangedFields ();
 
 			if (fields .length === 0)
 			{
@@ -397,32 +365,28 @@ function (FieldDefinitionArray,
 
 				generator .IncIndent ();
 
-				var references = [ ];
+				const references = [ ];
 
-				for (var i = 0, length = fields .length; i < length; ++ i)
+				for (const field of fields)
 				{
-					var field = fields [i];
-
 					// If the field is a inputOutput and we have as reference only inputOnly or outputOnly we must output the value
 					// for this field.
 
-					var mustOutputValue = false;
+					let mustOutputValue = false;
 
 					if (generator .ExecutionContext ())
 					{
 						if (field .getAccessType () === X3DConstants .inputOutput && field .getReferences () .size !== 0)
 						{
-							var
-								initializableReference = false,
-								fieldReferences        = field .getReferences ();
+							let initializableReference = false;
 
-							for (var fieldReference of fieldReferences .values ())
+							field .getReferences () .forEach (function (fieldReference)
 							{
-								initializableReference |= fieldReference .isInitializable ();
-							}
+								initializableReference = initializableReference || fieldReference .isInitializable ();
+							});
 
 							if (! initializableReference)
-								mustOutputValue = true;
+								mustOutputValue = ! this .isDefaultValue (field);
 						}
 					}
 
@@ -484,7 +448,7 @@ function (FieldDefinitionArray,
 									stream .string += generator .XMLEncode (field .getName ());
 									stream .string += "'";
 									stream .string += ">\n";
-									
+
 									generator .IncIndent ();
 
 									field .toXMLStream (stream);
@@ -494,12 +458,12 @@ function (FieldDefinitionArray,
 									generator .DecIndent ();
 
 									stream .string += generator .Indent ();
-									stream .string += "</fieldValue>\n";	
-	
+									stream .string += "</fieldValue>\n";
+
 									generator .PopContainerField ();
 									break;
 								}
-		
+
 								// Proceed with next case.
 							}
 							default:
@@ -534,14 +498,12 @@ function (FieldDefinitionArray,
 					stream .string += "\n";
 
 					generator .IncIndent ();
-		
-					for (var i = 0, length = references .length; i < length; ++ i)
+
+					for (const field of references)
 					{
-						var
-							field       = references [i],
-							protoFields = field .getReferences ();
+						const protoFields = field .getReferences ();
 
-						for (var protoField of protoFields .values ())
+						protoFields .forEach (function (protoField)
 						{
 							stream .string += generator .Indent ();
 							stream .string += "<connect";
@@ -554,7 +516,7 @@ function (FieldDefinitionArray,
 							stream .string += generator .XMLEncode (protoField .getName ());
 							stream .string += "'";
 							stream .string += "/>\n";
-						}
+						});
 					}
 
 					generator .DecIndent ();
@@ -575,5 +537,3 @@ function (FieldDefinitionArray,
 
 	return X3DPrototypeInstance;
 });
-
-

package/src/x_ite/Components/Core.js

@@ -81,7 +81,7 @@ function (SupportedNodes,
 {
 "use strict";
 
-	var Types =
+	const Types =
 	{
 		MetadataBoolean: MetadataBoolean,
 		MetadataDouble:  MetadataDouble,
@@ -92,7 +92,7 @@ function (SupportedNodes,
 		WorldInfo:       WorldInfo,
 	};
 
-	var AbstractTypes =
+	const AbstractTypes =
 	{
 		X3DBindableNode:      X3DBindableNode,
 		X3DChildNode:         X3DChildNode,
@@ -102,13 +102,10 @@ function (SupportedNodes,
 		X3DPrototypeInstance: X3DPrototypeInstance,
 		X3DSensorNode:        X3DSensorNode,
 	};
-	
-	for (var typeName in Types)
-		SupportedNodes .addType (typeName, Types [typeName]); 
 
-	for (var typeName in AbstractTypes)
-		SupportedNodes .addAbstractType (typeName, AbstractTypes [typeName]); 
+	for (const typeName in Types)
+		SupportedNodes .addType (typeName, Types [typeName]);
 
-	return Types;
+	for (const typeName in AbstractTypes)
+		SupportedNodes .addAbstractType (typeName, AbstractTypes [typeName]);
 });
-

package/src/x_ite/Components/CubeMapTexturing/ComposedCubeMapTexture.js

@@ -64,14 +64,19 @@ function (Fields,
 {
 "use strict";
 
-   var defaultData = new Uint8Array ([ 255, 255, 255, 255 ]);
-
 	function ComposedCubeMapTexture (executionContext)
 	{
 		X3DEnvironmentTextureNode .call (this, executionContext);
 
 		this .addType (X3DConstants .ComposedCubeMapTexture);
 
+		this .addAlias ("front",  this .frontTexture_);
+		this .addAlias ("back",   this .backTexture_);
+		this .addAlias ("left",   this .leftTexture_);
+		this .addAlias ("right",  this .rightTexture_);
+		this .addAlias ("bottom", this .bottomTexture_);
+		this .addAlias ("top",    this .topTexture_);
+
 		this .textures   = [null, null, null, null, null, null];
 		this .loadStates = 0;
 	}
@@ -80,13 +85,15 @@ function (Fields,
 	{
 		constructor: ComposedCubeMapTexture,
 		fieldDefinitions: new FieldDefinitionArray ([
-			new X3DFieldDefinition (X3DConstants .inputOutput, "metadata", new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "front",    new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "back",     new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "left",     new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "right",    new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "bottom",   new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "top",      new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",          new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "description",       new Fields .SFString ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "frontTexture",      new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "backTexture",       new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "leftTexture",       new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "rightTexture",      new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "bottomTexture",     new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "topTexture",        new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "textureProperties", new Fields .SFNode ()),
 		]),
 		getTypeName: function ()
 		{
@@ -106,32 +113,23 @@ function (Fields,
 
 			// Upload default data.
 
-			var gl = this .getBrowser () .getContext ();
-
-			gl .bindTexture (this .getTarget (), this .getTexture ());
-
-			for (var i = 0; i < 6; ++ i)
-				gl .texImage2D  (this .getTargets () [i], 0, gl .RGBA, 1, 1, 0, gl .RGBA, gl .UNSIGNED_BYTE, defaultData);
+			this .clearTexture ();
 
 			// Initialize.
 
-			this .isLive () .addInterest ("set_live__", this);
-
-			this .front_  .addInterest ("set_texture__", this, 0);
-			this .back_   .addInterest ("set_texture__", this, 1);
-			this .left_   .addInterest ("set_texture__", this, 2);
-			this .right_  .addInterest ("set_texture__", this, 3);
-			this .top_    .addInterest ("set_texture__", this, 5);
-			this .bottom_ .addInterest ("set_texture__", this, 4);
-
-			this .set_texture__ (this .front_,  0);
-			this .set_texture__ (this .back_,   1);
-			this .set_texture__ (this .left_,   2);
-			this .set_texture__ (this .right_,  3);
-			this .set_texture__ (this .top_,    4);
-			this .set_texture__ (this .bottom_, 5);
-
-			this .set_live__ ();
+			this .frontTexture_  .addInterest ("set_texture__", this, 0);
+			this .backTexture_   .addInterest ("set_texture__", this, 1);
+			this .leftTexture_   .addInterest ("set_texture__", this, 2);
+			this .rightTexture_  .addInterest ("set_texture__", this, 3);
+			this .topTexture_    .addInterest ("set_texture__", this, 5);
+			this .bottomTexture_ .addInterest ("set_texture__", this, 4);
+
+			this .set_texture__ (this .frontTexture_,  0);
+			this .set_texture__ (this .backTexture_,   1);
+			this .set_texture__ (this .leftTexture_,   2);
+			this .set_texture__ (this .rightTexture_,  3);
+			this .set_texture__ (this .topTexture_,    4);
+			this .set_texture__ (this .bottomTexture_, 5);
 		},
 		set_texture__: function (node, index)
 		{
@@ -160,15 +158,15 @@ function (Fields,
 		set_loadState__: function (output, texture, index)
 		{
 			if (texture)
-				this .setLoadStateBit (texture .checkLoadState (), index);
+				this .setLoadStateBit (texture .checkLoadState (), texture .getData (), index);
 			else
-				this .setLoadStateBit (X3DConstants .NOT_STARTED, index);
+				this .setLoadStateBit (X3DConstants .NOT_STARTED, null, index);
 
 			this .setTextures ();
 		},
-		setLoadStateBit: function (loadState, bit)
+		setLoadStateBit: function (loadState, data, bit)
 		{
-			if (loadState === X3DConstants .COMPLETE_STATE)
+			if (loadState === X3DConstants .COMPLETE_STATE || data)
 				this .loadStates |= 1 << bit;
 			else
 				this .loadStates &= ~(1 << bit);
@@ -214,7 +212,7 @@ function (Fields,
 						width   = texture .getWidth (),
 						height  = texture .getHeight (),
 						data    = texture .getData ();
-	
+
 					gl .pixelStorei (gl .UNPACK_FLIP_Y_WEBGL, !texture .getFlipY ());
 					gl .pixelStorei (gl .UNPACK_ALIGNMENT, 1);
 
@@ -228,14 +226,11 @@ function (Fields,
 					}
 				}
 
-				this .set_textureQuality__ ();
+				this .updateTextureProperties ();
 			}
 			else
 			{
-				for (var i = 0; i < 6; ++ i)
-				{
-					gl .texImage2D (this .getTargets () [i], 0, gl .RGBA, 1, 1, false, gl .RGBA, gl .UNSIGNED_BYTE, defaultData);
-				}
+				this .clearTexture ();
 			}
 
 			this .set_transparent__ ();
@@ -258,12 +253,9 @@ function (Fields,
 				}
 			}
 
-			if (transparent !== this .transparent_ .getValue ())
-				this .transparent_ = transparent;
+			this .setTransparent (transparent);
 		},
 	});
 
 	return ComposedCubeMapTexture;
 });
-
-