x_ite 4.2.17 → 4.7.7

package/src/x_ite/Components/VolumeRendering/X3DVolumeDataNode.js

@@ -48,28 +48,180 @@
 
 
 define ([
+	"x_ite/Fields",
 	"x_ite/Components/Core/X3DChildNode",
 	"x_ite/Components/Grouping/X3DBoundedObject",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Browser/Core/TextureQuality",
+	"standard/Math/Numbers/Vector3",
 ],
-function (X3DChildNode,
+function (Fields,
+          X3DChildNode,
           X3DBoundedObject,
-          X3DConstants)
+          X3DConstants,
+          TextureQuality,
+          Vector3)
 {
 "use strict";
 
 	function X3DVolumeDataNode (executionContext)
 	{
-		X3DChildNode .call (this, executionContext);
+		X3DChildNode     .call (this, executionContext);
 		X3DBoundedObject .call (this, executionContext);
 
 		this .addType (X3DConstants .X3DVolumeDataNode);
+
+		this .proximitySensorNode   = executionContext .createNode ("ProximitySensor", false);
+		this .transformNode         = executionContext .createNode ("Transform", false);
+		this .shapeNode             = executionContext .createNode ("Shape", false);
+		this .appearanceNode        = executionContext .createNode ("Appearance", false);
+		this .textureTransformNode  = executionContext .createNode ("TextureTransform3D", false);
+		this .geometryNode          = executionContext .createNode ("QuadSet", false);
+		this .textureCoordinateNode = executionContext .createNode ("TextureCoordinate3D", false);
+		this .coordinateNode        = executionContext .createNode ("Coordinate", false);
+
+		this .setCameraObject (true);
 	}
 
 	X3DVolumeDataNode .prototype = Object .assign (Object .create (X3DChildNode .prototype),
 		X3DBoundedObject .prototype,
 	{
 		constructor: X3DVolumeDataNode,
+		initialize: function ()
+		{
+			X3DChildNode     .prototype .initialize .call (this);
+			X3DBoundedObject .prototype .initialize .call (this);
+
+			var
+				browser = this .getBrowser (),
+				gl      = browser .getContext ();
+
+			browser .getBrowserOptions () .TextureQuality_ .addInterest ("set_dimensions__", this);
+
+			if (gl .getVersion () >= 2)
+			{
+				this .dimensions_ .addInterest ("set_dimensions__", this);
+
+				this .set_dimensions__ ();
+			}
+
+			this .appearanceNode .setPrivate (true);
+
+			this .proximitySensorNode .size_         = new Fields .SFVec3f (-1, -1, -1);
+			this .transformNode .children_           = new Fields .MFNode (this .shapeNode);
+			this .shapeNode .appearance_             = this .appearanceNode;
+			this .shapeNode .geometry_               = this .geometryNode;
+			this .appearanceNode .alphaMode_         = "BLEND";
+			this .appearanceNode .textureTransform_  = this .textureTransformNode;
+			this .textureTransformNode .translation_ = new Fields .SFVec3f (0.5, 0.5, 0.5);
+			this .textureTransformNode .center_      = new Fields .SFVec3f (-0.5, -0.5, -0.5);
+			this .geometryNode .texCoord_            = this .textureCoordinateNode;
+			this .geometryNode .coord_               = this .coordinateNode;
+
+			this .coordinateNode        .setup ();
+			this .textureCoordinateNode .setup ();
+			this .geometryNode          .setup ();
+			this .textureTransformNode  .setup ();
+			this .appearanceNode        .setup ();
+			this .shapeNode             .setup ();
+			this .transformNode         .setup ();
+			this .proximitySensorNode   .setup ();
+
+			this .proximitySensorNode .orientation_changed_ .addFieldInterest (this .transformNode .rotation_);
+			this .proximitySensorNode .orientation_changed_ .addFieldInterest (this .textureTransformNode .rotation_);
+
+			this .textureTransformNode .addInterest ("set_textureTransform__", this);
+		},
+		getBBox: function (bbox, shadow)
+		{
+			if (this .bboxSize_ .getValue () .equals (this .getDefaultBBoxSize ()))
+				return bbox .set (this .dimensions_ .getValue (), Vector3 .Zero);
+
+			return bbox .set (this .bboxSize_ .getValue (), this .bboxCenter_ .getValue ());
+		},
+		getAppearance: function ()
+		{
+			return this .appearanceNode;
+		},
+		setShader: function (shaderNode)
+		{
+			this .getAppearance () .shaders_ [0] = shaderNode;
+
+			shaderNode .addUserDefinedField (X3DConstants .inputOutput, "x3d_TextureNormalMatrix" , new Fields .SFMatrix3f ());
+			shaderNode .setup ();
+
+			this .set_textureTransform__ ();
+		},
+		getShader: function ()
+		{
+			var node = this .appearanceNode .shaders_ [0];
+
+			if (node)
+				return node .getValue ();
+
+			return null;
+		},
+		getNumPlanes: function ()
+		{
+			switch (this .getBrowser () .getBrowserOptions () .getTextureQuality ())
+			{
+				case TextureQuality .LOW:
+				{
+					return 200;
+				}
+				case TextureQuality .MEDIUM:
+				{
+					return 400;
+				}
+				case TextureQuality .HIGH:
+				{
+					return 600;
+				}
+			}
+
+			return 200;
+		},
+		set_dimensions__: function ()
+		{
+			var
+				NUM_PLANES = this .getNumPlanes (),
+				size       = this .dimensions_ .getValue () .abs (),
+				size1_2    = size / 2,
+				points     = [ ];
+
+			this .coordinateNode .point_ .length = 0;
+
+			for (var i = 0; i < NUM_PLANES; ++ i)
+			{
+				var z = i / (NUM_PLANES - 1) - 0.5;
+
+				points .push ( size1_2,  size1_2, size * z,
+				              -size1_2,  size1_2, size * z,
+				              -size1_2, -size1_2, size * z,
+				               size1_2, -size1_2, size * z);
+			}
+
+			this .coordinateNode .point_        = points;
+			this .textureCoordinateNode .point_ = points;
+
+			this .textureTransformNode .scale_ = new Fields .SFVec3f (1 / this .dimensions_ .x, 1 / this .dimensions_ .y, 1 / this .dimensions_ .z);
+		},
+		set_textureTransform__: function ()
+		{
+			var shaderNode = this .getShader ();
+
+			if (shaderNode)
+			{
+				var invTextureMatrix = shaderNode .getField ("x3d_TextureNormalMatrix");
+
+				invTextureMatrix .setValue (this .textureTransformNode .getMatrix () .submatrix .inverse () .transpose ());
+			}
+		},
+		traverse: function (type, renderObject)
+		{
+			this .proximitySensorNode .traverse (type, renderObject);
+			this .transformNode       .traverse (type, renderObject);
+		}
 	});
 
 	return X3DVolumeDataNode;

package/src/x_ite/Components/VolumeRendering/X3DVolumeRenderStyleNode.js

@@ -61,11 +61,73 @@ function (X3DNode,
 		X3DNode .call (this, executionContext);
 
 		this .addType (X3DConstants .X3DVolumeRenderStyleNode);
+
+		this .volumeDataNodes = new Set ();
 	}
 
 	X3DVolumeRenderStyleNode .prototype = Object .assign (Object .create (X3DNode .prototype),
 	{
 		constructor: X3DVolumeRenderStyleNode,
+		addShaderFields: function (shaderNode)
+		{ },
+		getUniformsText: function ()
+		{
+			return "";
+		},
+		getFunctionsText: function ()
+		{
+			return "";
+		},
+		getVolumeData: function ()
+		{
+			return this .volumeDataNodes;
+		},
+		addVolumeData: function (volumeDataNode)
+		{
+			this .volumeDataNodes .add (volumeDataNode);
+		},
+		removeVolumeData: function (volumeDataNode)
+		{
+			this .volumeDataNodes .delete (volumeDataNode);
+		},
+		getNormalText: function (surfaceNormalsNode)
+		{
+			var string = "";
+
+			if (surfaceNormalsNode)
+			{
+				string += "uniform sampler3D surfaceNormals_" + this .getId () + ";\n";
+
+				string += "\n";
+				string += "vec4\n";
+				string += "getNormal_" + this .getId () + " (in vec3 texCoord)\n";
+				string += "{\n";
+				string += "	vec3 n = texture (surfaceNormals_" + this .getId () + ", texCoord) .xyz * 2.0 - 1.0;\n";
+				string += "\n";
+				string += "	return vec4 (normalize (x3d_TextureNormalMatrix * n), length (n));\n";
+				string += "}\n";
+			}
+			else
+			{
+				string += "\n";
+				string += "vec4\n";
+				string += "getNormal_" + this .getId () + " (in vec3 texCoord)\n";
+				string += "{\n";
+				string += "	vec4  offset = vec4 (1.0 / x3d_TextureSize, 0.0);\n";
+				string += "	float i0     = texture (x3d_Texture3D [0], texCoord + offset .xww) .r;\n";
+				string += "	float i1     = texture (x3d_Texture3D [0], texCoord - offset .xww) .r;\n";
+				string += "	float i2     = texture (x3d_Texture3D [0], texCoord + offset .wyw) .r;\n";
+				string += "	float i3     = texture (x3d_Texture3D [0], texCoord - offset .wyw) .r;\n";
+				string += "	float i4     = texture (x3d_Texture3D [0], texCoord + offset .wwz) .r;\n";
+				string += "	float i5     = texture (x3d_Texture3D [0], texCoord - offset .wwz) .r;\n";
+				string += "	vec3  n      = vec3 (i1 - i0, i3 - i2, i5 - i4);\n";
+				string += "\n";
+				string += "	return vec4 (normalize (x3d_TextureNormalMatrix * n), length (n));\n";
+				string += "}\n";
+			}
+
+			return string;
+		},
 	});
 
 	return X3DVolumeRenderStyleNode;

package/src/x_ite/Components/X_ITE/BlendMode.js

@@ -70,8 +70,8 @@ function (Fields,
 
 		this .addType (X3DConstants .BlendMode);
 
-		this .blendTypes = { };
-		this .blendModes = { };
+		this .factorTypes   = new Map ();
+		this .equationTypes = new Map ();
 	}
 
 	BlendMode .prototype = Object .assign (Object .create (X3DAppearanceChildNode .prototype),
@@ -81,8 +81,8 @@ function (Fields,
 			new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",                new Fields .SFNode ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "blendColor",              new Fields .SFColorRGBA ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "sourceColorFactor",       new Fields .SFString ("SRC_ALPHA")),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "sourceAlphaFactor",       new Fields .SFString ("ONE_MINUS_SRC_ALPHA")),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "destinationColorFactor",  new Fields .SFString ("ONE")),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "sourceAlphaFactor",       new Fields .SFString ("ONE")),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "destinationColorFactor",  new Fields .SFString ("ONE_MINUS_SRC_ALPHA")),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "destinationAlphaFactor",  new Fields .SFString ("ONE_MINUS_SRC_ALPHA")),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "colorEquation",           new Fields .SFString ("FUNC_ADD")),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "alphaEquation",           new Fields .SFString ("FUNC_ADD")),
@@ -107,34 +107,34 @@ function (Fields,
 				gl  = this .getBrowser () .getContext (),
 				ext = gl .getExtension ('EXT_blend_minmax');
 
-			this .blendTypes ["ZERO"]                     = gl .ZERO;
-			this .blendTypes ["ONE"]                      = gl .ONE;
-			this .blendTypes ["SRC_COLOR"]                = gl .SRC_COLOR;
-			this .blendTypes ["ONE_MINUS_SRC_COLOR"]      = gl .ONE_MINUS_SRC_COLOR;
-			this .blendTypes ["DST_COLOR"]                = gl .DST_COLOR;
-			this .blendTypes ["ONE_MINUS_DST_COLOR"]      = gl .ONE_MINUS_DST_COLOR;
-			this .blendTypes ["SRC_ALPHA"]                = gl .SRC_ALPHA;
-			this .blendTypes ["ONE_MINUS_SRC_ALPHA"]      = gl .ONE_MINUS_SRC_ALPHA;
-			this .blendTypes ["DST_ALPHA"]                = gl .DST_ALPHA;
-			this .blendTypes ["ONE_MINUS_DST_ALPHA"]      = gl .ONE_MINUS_DST_ALPHA;
-			this .blendTypes ["SRC_ALPHA_SATURATE"]       = gl .SRC_ALPHA_SATURATE;
-			this .blendTypes ["CONSTANT_COLOR"]           = gl .CONSTANT_COLOR;
-			this .blendTypes ["ONE_MINUS_CONSTANT_COLOR"] = gl .ONE_MINUS_CONSTANT_COLOR;
-			this .blendTypes ["CONSTANT_ALPHA"]           = gl .CONSTANT_ALPHA;
-			this .blendTypes ["ONE_MINUS_CONSTANT_ALPHA"] = gl .ONE_MINUS_CONSTANT_ALPHA;
-
-			this .blendModes ["FUNC_ADD"]              = gl .FUNC_ADD;
-			this .blendModes ["FUNC_SUBTRACT"]         = gl .FUNC_SUBTRACT;
-			this .blendModes ["FUNC_REVERSE_SUBTRACT"] = gl .FUNC_REVERSE_SUBTRACT;
-			this .blendModes ["MIN"]                   = gl .MIN || ext .MIN_EXT;
-			this .blendModes ["MAX"]                   = gl .MAX || ext .MAX_EXT;
-
-			this .sourceColorFactor_      .addInterest ("set_sourceColorFactor__", this);
-			this .sourceAlphaFactor_      .addInterest ("set_sourceAlphaFactor__", this);
-			this .destinationColorFactor_ .addInterest ("set_destinationColorFactor__",  this);
-			this .destinationAlphaFactor_ .addInterest ("set_destinationAlphaFactor__",  this);
-			this .colorEquation_          .addInterest ("set_colorEquation__",     this);
-			this .alphaEquation_          .addInterest ("set_alphaEquation__",     this);
+			this .factorTypes .set ("ZERO",                     gl .ZERO);
+			this .factorTypes .set ("ONE",                      gl .ONE);
+			this .factorTypes .set ("SRC_COLOR",                gl .SRC_COLOR);
+			this .factorTypes .set ("ONE_MINUS_SRC_COLOR",      gl .ONE_MINUS_SRC_COLOR);
+			this .factorTypes .set ("DST_COLOR",                gl .DST_COLOR);
+			this .factorTypes .set ("ONE_MINUS_DST_COLOR",      gl .ONE_MINUS_DST_COLOR);
+			this .factorTypes .set ("SRC_ALPHA",                gl .SRC_ALPHA);
+			this .factorTypes .set ("ONE_MINUS_SRC_ALPHA",      gl .ONE_MINUS_SRC_ALPHA);
+			this .factorTypes .set ("DST_ALPHA",                gl .DST_ALPHA);
+			this .factorTypes .set ("ONE_MINUS_DST_ALPHA",      gl .ONE_MINUS_DST_ALPHA);
+			this .factorTypes .set ("SRC_ALPHA_SATURATE",       gl .SRC_ALPHA_SATURATE);
+			this .factorTypes .set ("CONSTANT_COLOR",           gl .CONSTANT_COLOR);
+			this .factorTypes .set ("ONE_MINUS_CONSTANT_COLOR", gl .ONE_MINUS_CONSTANT_COLOR);
+			this .factorTypes .set ("CONSTANT_ALPHA",           gl .CONSTANT_ALPHA);
+			this .factorTypes .set ("ONE_MINUS_CONSTANT_ALPHA", gl .ONE_MINUS_CONSTANT_ALPHA);
+
+			this .equationTypes .set ("FUNC_ADD",              gl .FUNC_ADD);
+			this .equationTypes .set ("FUNC_SUBTRACT",         gl .FUNC_SUBTRACT);
+			this .equationTypes .set ("FUNC_REVERSE_SUBTRACT", gl .FUNC_REVERSE_SUBTRACT);
+			this .equationTypes .set ("MIN",                   gl .MIN || (ext && ext .MIN_EXT));
+			this .equationTypes .set ("MAX",                   gl .MAX || (ext && ext .MAX_EXT));
+
+			this .sourceColorFactor_      .addInterest ("set_sourceColorFactor__",      this);
+			this .sourceAlphaFactor_      .addInterest ("set_sourceAlphaFactor__",      this);
+			this .destinationColorFactor_ .addInterest ("set_destinationColorFactor__", this);
+			this .destinationAlphaFactor_ .addInterest ("set_destinationAlphaFactor__", this);
+			this .colorEquation_          .addInterest ("set_colorEquation__",          this);
+			this .alphaEquation_          .addInterest ("set_alphaEquation__",          this);
 
 			this .set_sourceColorFactor__ ();
 			this .set_sourceAlphaFactor__ ();
@@ -145,52 +145,52 @@ function (Fields,
 		},
 		set_sourceColorFactor__: function ()
 		{
-			this .sourceColorFactorType = this .blendTypes [this .sourceColorFactor_ .getValue ()];
+			this .sourceColorFactorType = this .factorTypes .get (this .sourceColorFactor_ .getValue ());
 
-			if (! this .sourceColorFactorType)
-				this .sourceColorFactorType = this .blendTypes ["SRC_ALPHA"];
+			if (this .sourceColorFactorType === undefined)
+				this .sourceColorFactorType = this .factorTypes .get ("SRC_ALPHA");
 		},
 		set_sourceAlphaFactor__: function ()
 		{
-			this .sourceAlphaFactorType = this .blendTypes [this .sourceAlphaFactor_ .getValue ()];
+			this .sourceAlphaFactorType = this .factorTypes .get (this .sourceAlphaFactor_ .getValue ());
 
-			if (! this .sourceAlphaFactorType)
-				this .sourceAlphaFactorType = this .blendTypes ["ONE_MINUS_SRC_ALPHA"];
+			if (this .sourceAlphaFactorType === undefined)
+				this .sourceAlphaFactorType = this .factorTypes .get ("ONE");
 		},
 		set_destinationColorFactor__: function ()
 		{
-			this .destinationColorFactorType = this .blendTypes [this .destinationColorFactor_ .getValue ()];
+			this .destinationColorFactorType = this .factorTypes .get (this .destinationColorFactor_ .getValue ());
 
-			if (! this .destinationColorFactorType)
-				this .destinationColorFactorType = this .blendTypes ["ONE"];
+			if (this .destinationColorFactorType === undefined)
+				this .destinationColorFactorType = this .factorTypes .get ("ONE_MINUS_SRC_ALPHA");
 		},
 		set_destinationAlphaFactor__: function ()
 		{
-			this .destinationAlphaFactorType = this .blendTypes [this .destinationAlphaFactor_ .getValue ()];
+			this .destinationAlphaFactorType = this .factorTypes .get (this .destinationAlphaFactor_ .getValue ());
 
-			if (! this .destinationAlphaFactorType)
-				this .destinationAlphaFactorType = this .blendTypes ["ONE_MINUS_SRC_ALPHA"];
+			if (this .destinationAlphaFactorType === undefined)
+				this .destinationAlphaFactorType = this .factorTypes .get ("ONE_MINUS_SRC_ALPHA");
 		},
 		set_colorEquation__: function ()
 		{
-			this .colorEquationType = this .blendModes [this .colorEquation_ .getValue ()];
+			this .colorEquationType = this .equationTypes .get (this .colorEquation_ .getValue ());
 
-			if (! this .colorEquationType)
-				this .colorEquationType = this .blendModes ["FUNC_ADD"];
+			if (this .colorEquationType === undefined)
+				this .colorEquationType = this .equationTypes .get ("FUNC_ADD");
 		},
 		set_alphaEquation__: function ()
 		{
-			this .alphaEquationType = this .blendModes [this .alphaEquation_ .getValue ()];
+			this .alphaEquationType = this .equationTypes .get (this .alphaEquation_ .getValue ());
 
-			if (! this .alphaEquationType)
-				this .alphaEquationType = this .blendModes ["FUNC_ADD"];
+			if (this .alphaEquationType === undefined)
+				this .alphaEquationType = this .equationTypes .get ("FUNC_ADD");
 		},
 		enable: function (gl)
 		{
 			var color = this .blendColor_ .getValue ();
 
 			gl .blendColor (color .r, color .g, color .b, color .a);
-			gl .blendFuncSeparate (this .sourceColorFactorType, this .sourceAlphaFactorType, this .destinationColorFactorType, this .destinationAlphaFactorType);
+			gl .blendFuncSeparate (this .sourceColorFactorType, this .destinationColorFactorType, this .sourceAlphaFactorType, this .destinationAlphaFactorType);
 			gl .blendEquationSeparate (this .colorEquationType, this .alphaEquationType);
 		},
 		disable: function (gl)

package/src/x_ite/Components.js

@@ -48,39 +48,31 @@
 
 
 define ([
+	"x_ite/DEBUG",
 	"x_ite/Browser/X3DBrowserContext",
 	"x_ite/Configuration/SupportedNodes",
 	"x_ite/Components/Core",
-	"x_ite/Components/CubeMapTexturing",
-	"x_ite/Components/DIS",
 	"x_ite/Components/EnvironmentalEffects",
 	"x_ite/Components/EnvironmentalSensor",
-	"x_ite/Components/EventUtilities",
 	"x_ite/Components/Followers",
-	"x_ite/Components/Geometry2D",
 	"x_ite/Components/Geometry3D",
 	"x_ite/Components/Grouping",
 	"x_ite/Components/Interpolation",
-	"x_ite/Components/KeyDeviceSensor",
 	"x_ite/Components/Layering",
-	"x_ite/Components/Layout",
 	"x_ite/Components/Lighting",
 	"x_ite/Components/Navigation",
 	"x_ite/Components/Networking",
-	"x_ite/Components/Picking",
 	"x_ite/Components/PointingDeviceSensor",
 	"x_ite/Components/Rendering",
-	"x_ite/Components/Scripting",
 	"x_ite/Components/Shaders",
 	"x_ite/Components/Shape",
 	"x_ite/Components/Sound",
 	"x_ite/Components/Text",
 	"x_ite/Components/Texturing",
 	"x_ite/Components/Time",
-	"x_ite/Components/VolumeRendering",
-	"x_ite/Components/X_ITE",
 ],
-function (X3DBrowserContext,
+function (DEBUG,
+          X3DBrowserContext,
           SupportedNodes)
 {
 "use strict";
@@ -93,21 +85,24 @@ function (X3DBrowserContext,
 		{
 			if (component .types)
 			{
-				for (var typeName in component .types)
-					SupportedNodes .addType (typeName, component .types [typeName]); 
+				for (const typeName in component .types)
+					SupportedNodes .addType (typeName, component .types [typeName]);
 			}
 
 			if (component .abstractTypes)
 			{
-				for (var typeName in component .abstractTypes)
+				for (const typeName in component .abstractTypes)
 					SupportedNodes .addAbstractType (typeName, component .abstractTypes [typeName]);
 			}
 
 			if (component .browser)
-				Object .assign (X3DBrowserContext .prototype, component .browser);
+				X3DBrowserContext .addContext (component .browser);
 
 			if (component .name)
-				console .log ("Done loading component '" + component .name + "'.");
+			{
+				if (DEBUG)
+					console .log ("Done loading external component '" + component .name + "'.");
+			}
 		},
 	};
 

package/src/x_ite/Configuration/ComponentInfo.js

@@ -64,18 +64,24 @@ function (Fields,
 		this .level       = level;
 		this .title       = title;
 		this .providerUrl = providerUrl;
-
-		Object .preventExtensions (this);
-		Object .freeze (this);
-		Object .seal (this);
 	}
 
 	Object .assign (ComponentInfo .prototype,
 	{
 		constructor: ComponentInfo,
+		toVRMLStream: function (stream)
+		{
+			stream .string += "COMPONENT";
+			stream .string += " ";
+			stream .string += this .name;
+			stream .string += " ";
+			stream .string += ":";
+			stream .string += " ";
+			stream .string += this .level;
+		},
 		toXMLStream: function (stream)
 		{
-			var generator = Generator .Get (stream);
+			const generator = Generator .Get (stream);
 
 			stream .string += generator .Indent ();
 			stream .string += "<component";
@@ -92,4 +98,4 @@ function (Fields,
 	});
 
 	return ComponentInfo;
-});
+});

package/src/x_ite/Configuration/ComponentInfoArray.js

@@ -58,13 +58,10 @@ function (ComponentInfo,
 
 	function ComponentInfoArray (array)
 	{
-		var proxy = X3DInfoArray .call (this);
-	
-		if (array)
-		{
-			for (var i = 0, length = array .length; i < length; ++ i)
-				this .add (array [i] .name, array [i]);
-		}
+		const proxy = X3DInfoArray .call (this);
+
+		for (const componentInfo of array)
+			this .add (componentInfo .name, componentInfo);
 
 		return proxy;
 	}

package/src/x_ite/Configuration/ProfileInfo.js

@@ -57,18 +57,22 @@ define (function ()
 		this .title       = title;
 		this .providerUrl = providerUrl;
 		this .components  = components;
-
-		Object .preventExtensions (this);
-		Object .freeze (this);
-		Object .seal (this);
 	}
 
 	Object .assign (ProfileInfo .prototype,
 	{
 		constructor: ProfileInfo,
+		toVRMLStream: function (stream)
+		{
+			stream .string += "PROFILE";
+			stream .string += " ";
+			stream .string += this .name;
+		},
 		toXMLStream: function (stream)
-		{ },
+		{
+			stream .string += this .name;
+		},
 	});
 
 	return ProfileInfo;
-});
+});