x_ite 4.2.17 → 4.7.7

package/src/x_ite/Components/Geometry3D/IndexedFaceSet.js

@@ -60,7 +60,7 @@ define ([
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DComposedGeometryNode, 
+          X3DComposedGeometryNode,
           X3DConstants,
           Vector3,
           Matrix4,
@@ -68,14 +68,6 @@ function (Fields,
 {
 "use strict";
 
-	var
-		Triangle    = [0, 1, 2],
-		Polygon     = [ ],
-		normals     = [ ],
-		normalIndex = [ ],
-		current     = new Vector3 (0, 0, 0),
-		next        = new Vector3 (0, 0, 0);
-
 	function IndexedFaceSet (executionContext)
 	{
 		X3DComposedGeometryNode .call (this, executionContext);
@@ -89,23 +81,27 @@ function (Fields,
 	{
 		constructor: IndexedFaceSet,
 		fieldDefinitions: new FieldDefinitionArray ([
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",        new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "solid",           new Fields .SFBool (true)),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "ccw",             new Fields .SFBool (true)),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "convex",          new Fields .SFBool (true)),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "creaseAngle",     new Fields .SFFloat ()),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "colorPerVertex",  new Fields .SFBool (true)),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "normalPerVertex", new Fields .SFBool (true)),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "colorIndex",      new Fields .MFInt32 ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "texCoordIndex",   new Fields .MFInt32 ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "normalIndex",     new Fields .MFInt32 ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "coordIndex",      new Fields .MFInt32 ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "attrib",          new Fields .MFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "fogCoord",        new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "color",           new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "texCoord",        new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "normal",          new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "coord",           new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",          new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOnly,      "set_colorIndex",    new Fields .MFInt32 ()),
+			new X3DFieldDefinition (X3DConstants .inputOnly,      "set_texCoordIndex", new Fields .MFInt32 ()),
+			new X3DFieldDefinition (X3DConstants .inputOnly,      "set_normalIndex",   new Fields .MFInt32 ()),
+			new X3DFieldDefinition (X3DConstants .inputOnly,      "set_coordIndex",    new Fields .MFInt32 ()),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "solid",             new Fields .SFBool (true)),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "ccw",               new Fields .SFBool (true)),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "convex",            new Fields .SFBool (true)),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "creaseAngle",       new Fields .SFFloat ()),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "colorPerVertex",    new Fields .SFBool (true)),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "normalPerVertex",   new Fields .SFBool (true)),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "colorIndex",        new Fields .MFInt32 ()),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "texCoordIndex",     new Fields .MFInt32 ()),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "normalIndex",       new Fields .MFInt32 ()),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "coordIndex",        new Fields .MFInt32 ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "attrib",            new Fields .MFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "fogCoord",          new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "color",             new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "texCoord",          new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "normal",            new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "coord",             new Fields .SFNode ()),
 		]),
 		getTypeName: function ()
 		{
@@ -119,6 +115,15 @@ function (Fields,
 		{
 			return "geometry";
 		},
+		initialize: function ()
+		{
+			X3DComposedGeometryNode .prototype .initialize .call (this);
+
+			this .set_colorIndex_    .addFieldInterest (this .colorIndex_);
+			this .set_texCoordIndex_ .addFieldInterest (this .texCoordIndex_);
+			this .set_normalIndex_   .addFieldInterest (this .normalIndex_);
+			this .set_coordIndex_    .addFieldInterest (this .coordIndex_);
+		},
 		getTexCoordPerVertexIndex: function (index)
 		{
 			if (index < this .texCoordIndex_ .length)
@@ -170,14 +175,16 @@ function (Fields,
 			var
 				colorPerVertex     = this .colorPerVertex_ .getValue (),
 				normalPerVertex    = this .normalPerVertex_ .getValue (),
-				coordIndex         = this .coordIndex_,
+				coordIndex         = this .coordIndex_ .getValue (),
 				attribNodes        = this .getAttrib (),
 				numAttrib          = attribNodes .length,
 				attribs            = this .getAttribs (),
+				fogCoordNode       = this .getFogCoord (),
 				colorNode          = this .getColor (),
 				texCoordNode       = this .getTexCoord (),
 				normalNode         = this .getNormal (),
 				coordNode          = this .getCoord (),
+				fogDepthArray      = this .getFogDepths (),
 				colorArray         = this .getColors (),
 				multiTexCoordArray = this .getMultiTexCoords (),
 				normalArray        = this .getNormals (),
@@ -190,19 +197,21 @@ function (Fields,
 			{
 				var
 					polygon   = polygons [p],
-					vertices  = polygon .vertices,
 					triangles = polygon .triangles,
 					face      = polygon .face;
 
 				for (var v = 0, numVertices = triangles .length; v < numVertices; ++ v)
 				{
 					var
-						i     = vertices [triangles [v]],
+						i     = triangles [v],
 						index = coordIndex [i];
 
 					for (var a = 0; a < numAttrib; ++ a)
 						attribNodes [a] .addValue (index, attribs [a]);
 
+					if (fogCoordNode)
+						fogCoordNode .addDepth (index, fogDepthArray);
+
 					if (colorNode)
 					{
 						if (colorPerVertex)
@@ -241,8 +250,7 @@ function (Fields,
 		{
 			var
 				convex      = this .convex_ .getValue (),
-				coordIndex  = this .coordIndex_,
-				coordLength = coordIndex .length,
+				coordLength = this .coordIndex_ .length,
 				polygons    = [ ];
 
 			if (! this .getCoord ())
@@ -251,12 +259,12 @@ function (Fields,
 			if (coordLength)
 			{
 				// Add -1 (polygon end marker) to coordIndex if not present.
-				if (coordIndex [coordLength - 1] > -1)
-				{
-					coordIndex .push (-1);
+				if (this .coordIndex_ [coordLength - 1] > -1)
+					this .coordIndex_ .push (-1);
 
-					++ coordLength;
-				}
+				var
+					coordIndex  = this .coordIndex_ .getValue (),
+					coordLength = this .coordIndex_ .length;
 
 				// Construct triangle array and determine the number of used points.
 				var
@@ -266,7 +274,7 @@ function (Fields,
 				for (var i = 0; i < coordLength; ++ i)
 				{
 					var index = coordIndex [i];
-	
+
 					if (index > -1)
 					{
 						// Add vertex index.
@@ -279,8 +287,8 @@ function (Fields,
 						if (vertices .length)
 						{
 							// Closed polygon.
-							if (vertices [0] === vertices [vertices .length - 1])
-								vertices .pop ();
+							//if (coordIndex [vertices [0]] === coordIndex [vertices [vertices .length - 1]])
+							//	vertices .pop ();
 
 							switch (vertices .length)
 							{
@@ -294,7 +302,7 @@ function (Fields,
 								case 3:
 								{
 									// Add polygon with one triangle.
-									polygons .push ({ vertices: vertices, triangles: Triangle, face: face });
+									polygons .push ({ vertices: vertices, triangles: vertices, face: face });
 									vertices = [ ];
 									break;
 								}
@@ -306,12 +314,14 @@ function (Fields,
 										polygon   = { vertices: vertices, triangles: triangles, face: face };
 
 									if (convex)
-										this .triangulateConvexPolygon (polygon);
+										this .triangulateConvexPolygon (vertices, triangles);
 									else
-										this .triangulatePolygon (polygon);
+										this .triangulatePolygon (vertices, triangles);
 
 									if (triangles .length < 3)
+									{
 										vertices .length = 0;
+									}
 									else
 									{
 										polygons .push (polygon);
@@ -322,7 +332,7 @@ function (Fields,
 								}
 							}
 						}
-						
+
 						++ face;
 					}
 				}
@@ -330,157 +340,169 @@ function (Fields,
 
 			return polygons;
 		},
-		triangulatePolygon: function (polygon)
+		triangulatePolygon: (function ()
 		{
-			// Transform vertices to 2D space.
+			var polygon = [ ];
 
-			var
-				vertices   = polygon .vertices,
-				triangles  = polygon .triangles,
-				coordIndex = this .coordIndex_,
-				coord      = this .getCoord ();
-
-			for (var i = 0, length = vertices .length; i < length; ++ i)
+			return function (vertices, triangles)
 			{
-				var vertex = coord .get1Point (coordIndex [vertices [i]], new Vector3 (0, 0, 0));
+				var
+					coordIndex = this .coordIndex_ .getValue (),
+					coord      = this .getCoord ();
 
-				vertex .index = i;
+				for (var v = 0, length = vertices .length; v < length; ++ v)
+				{
+					var
+						vertex = polygon [v],
+						i      = vertices [v];
 
-				Polygon [i] = vertex;
-			}
+					if (! vertex)
+						vertex = polygon [v] = new Vector3 (0, 0, 0);
 
-			Polygon .length = length;
+					vertex .index = i;
 
-			Triangle3 .triangulatePolygon (Polygon, triangles);
+					coord .get1Point (coordIndex [i], vertex);
+				}
 
-			for (var i = 0, length = triangles .length; i < length; ++ i)
-				triangles [i] = triangles [i] .index;
-		},
-		triangulateConvexPolygon: function (polygon)
-		{
-			var
-				vertices  = polygon .vertices,
-				triangles = polygon .triangles;
+				polygon .length = length;
 
+				Triangle3 .triangulatePolygon (polygon, triangles);
+
+				for (var i = 0, length = triangles .length; i < length; ++ i)
+					triangles [i] = triangles [i] .index;
+			};
+		})(),
+		triangulateConvexPolygon: function (vertices, triangles)
+		{
 			// Fallback: Very simple triangulation for convex polygons.
 			for (var i = 1, length = vertices .length - 1; i < length; ++ i)
-				triangles .push (0, i, i + 1);
+				triangles .push (vertices [0], vertices [i], vertices [i + 1]);
 		},
 		buildNormals: function (polygons)
 		{
 			var
-				first       = 0,
 				normals     = this .createNormals (polygons),
 				normalArray = this .getNormals ();
 
 			for (var p = 0, pl = polygons .length; p < pl; ++ p)
 			{
-				var
-					polygon   = polygons [p],
-					vertices  = polygon .vertices,
-					triangles = polygon .triangles;
+				var triangles = polygons [p] .triangles;
 
 				for (var v = 0, tl = triangles .length; v < tl; ++ v)
 				{
-					var normal = normals [first + triangles [v]];
+					var normal = normals [triangles [v]];
 
 					normalArray .push (normal .x, normal .y, normal .z);
 				}
-
-				first += vertices .length;
 			}
 		},
-		createNormals: function (polygons)
+		createNormals: (function ()
 		{
 			var
-				cw          = ! this .ccw_ .getValue (),
-				coordIndex  = this .coordIndex_,
-				coord       = this .getCoord (),
-				normal      = null;
-
-			normals     .length = 0;
-			normalIndex .length = 0;
+				normals     = [ ],
+				normalIndex = [ ];
 
-			for (var p = 0, pl = polygons .length; p < pl; ++ p)
+			return function (polygons)
 			{
 				var
-					polygon  = polygons [p],
-					vertices = polygon .vertices,
-					length   = vertices .length;
+					cw          = ! this .ccw_ .getValue (),
+					coordIndex  = this .coordIndex_ .getValue (),
+					coord       = this .getCoord (),
+					normal      = null;
+
+				normals     .length = 0;
+				normalIndex .length = 0;
 
-				switch (length)
+				for (var p = 0, pl = polygons .length; p < pl; ++ p)
 				{
-					case 3:
-					{
-						normal = coord .getNormal (coordIndex [vertices [0]],
-						                           coordIndex [vertices [1]],
-						                           coordIndex [vertices [2]]);
-						break;
-					}
-					case 4:
-					{
-						normal = coord .getQuadNormal (coordIndex [vertices [0]],
-						                               coordIndex [vertices [1]],
-						                               coordIndex [vertices [2]],
-						                               coordIndex [vertices [3]]);
-						break;
-					}
-					default:
+					var
+						polygon  = polygons [p],
+						vertices = polygon .vertices,
+						length   = vertices .length;
+
+					switch (length)
 					{
-						normal = this .getPolygonNormal (vertices, coordIndex, coord);
-						break;
+						case 3:
+						{
+							normal = coord .getNormal (coordIndex [vertices [0]],
+							                           coordIndex [vertices [1]],
+							                           coordIndex [vertices [2]]);
+							break;
+						}
+						case 4:
+						{
+							normal = coord .getQuadNormal (coordIndex [vertices [0]],
+							                               coordIndex [vertices [1]],
+							                               coordIndex [vertices [2]],
+							                               coordIndex [vertices [3]]);
+							break;
+						}
+						default:
+						{
+							normal = this .getPolygonNormal (vertices, coordIndex, coord);
+							break;
+						}
 					}
-				}
 
-				// Add a normal index for each point.
-				for (var i = 0; i < length; ++ i)
-				{
-					var index = coordIndex [vertices [i]];
+					// Add a normal index for each point.
 
-					if (! normalIndex [index])
-						normalIndex [index] = [ ];
+					for (var i = 0; i < length; ++ i)
+					{
+						var
+							index        = vertices [i],
+							point        = coordIndex [index],
+							pointNormals = normalIndex [point];
 
-					normalIndex [index] .push (normals .length + i);
-				}
+						if (! pointNormals)
+							pointNormals = normalIndex [point] = [ ];
 
-				if (cw)
-					normal .negate ();
+						pointNormals .push (index);
+					}
 
-				// Add this normal for each vertex.
+					if (cw)
+						normal .negate ();
 
-				for (var i = 0, nl = length; i < nl; ++ i)
-					normals .push (normal);
-			}
+					// Add this normal for each vertex.
 
-			return this .refineNormals (normalIndex, normals, this .creaseAngle_ .getValue ());
-		},
-		getPolygonNormal: function (vertices, coordIndex, coord)
+					for (var i = 0; i < length; ++ i)
+						normals [vertices [i]] = normal;
+				}
+
+				return this .refineNormals (normalIndex, normals, this .creaseAngle_ .getValue ());
+			};
+		})(),
+		getPolygonNormal: (function ()
 		{
-			// Determine polygon normal.
-			// We use Newell's method https://www.opengl.org/wiki/Calculating_a_Surface_Normal here:
+			var
+				current = new Vector3 (0, 0, 0),
+				next    = new Vector3 (0, 0, 0);
 
-			var normal = new Vector3 (0, 0, 0);
+			return function (vertices, coordIndex, coord)
+			{
+				// Determine polygon normal.
+				// We use Newell's method https://www.opengl.org/wiki/Calculating_a_Surface_Normal here:
 
-			coord .get1Point (coordIndex [vertices [0]], next);
+				var normal = new Vector3 (0, 0, 0);
 
-			for (var i = 0, length = vertices .length; i < length; ++ i)
-			{
-				var tmp = current;
-				current = next;
-				next    = tmp;
+				coord .get1Point (coordIndex [vertices [0]], next);
 
-				coord .get1Point (coordIndex [vertices [(i + 1) % length]], next);
+				for (var i = 0, length = vertices .length; i < length; ++ i)
+				{
+					var tmp = current;
+					current = next;
+					next    = tmp;
 
-				normal .x += (current .y - next .y) * (current .z + next .z);
-				normal .y += (current .z - next .z) * (current .x + next .x);
-				normal .z += (current .x - next .x) * (current .y + next .y);
-			}
+					coord .get1Point (coordIndex [vertices [(i + 1) % length]], next);
 
-			return normal .normalize ();
-		},
+					normal .x += (current .y - next .y) * (current .z + next .z);
+					normal .y += (current .z - next .z) * (current .x + next .x);
+					normal .z += (current .x - next .x) * (current .y + next .y);
+				}
+
+				return normal .normalize ();
+			};
+		})(),
 	});
 
 	return IndexedFaceSet;
 });
-
-

package/src/x_ite/Components/Geometry3D/Sphere.js

@@ -57,7 +57,7 @@ define ([
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DGeometryNode, 
+          X3DGeometryNode,
           X3DConstants)
 {
 "use strict";
@@ -94,7 +94,7 @@ function (Fields,
 		set_live__: function ()
 		{
 			X3DGeometryNode .prototype .set_live__ .call (this);
-		   
+
 			if (this .isLive () .getValue ())
 				this .getBrowser () .getSphereOptions () .addInterest ("requestRebuild", this);
 			else
@@ -113,7 +113,7 @@ function (Fields,
 			if (radius === 1)
 			{
 				this .setVertices (geometry .getVertices ());
-	
+
 				this .getMin () .assign (geometry .getMin ());
 				this .getMax () .assign (geometry .getMax ());
 			}
@@ -143,5 +143,3 @@ function (Fields,
 
 	return Sphere;
 });
-
-

package/src/x_ite/Components/Geometry3D.js

@@ -67,7 +67,7 @@ function (SupportedNodes,
 {
 "use strict";
 
-	var Types =
+	const Types =
 	{
 		Box:            Box,
 		Cone:           Cone,
@@ -78,16 +78,13 @@ function (SupportedNodes,
 		Sphere:         Sphere,
 	};
 
-	var AbstractTypes =
+	const AbstractTypes =
 	{
 	};
-	
-	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/Geospatial/GeoElevationGrid.js

@@ -140,25 +140,25 @@ function (Fields,
 		{
 			if (this .colorNode)
 			{
-				this .colorNode .removeInterest ("requestRebuild",    this);
-				this .colorNode .removeInterest ("set_transparent__", this);
+				this .colorNode .removeInterest ("requestRebuild", this);
+				this .colorNode .transparent_ .removeInterest ("set_transparent__", this);
 			}
 
 			this .colorNode = X3DCast (X3DConstants .X3DColorNode, this .color_);
 
 			if (this .colorNode)
 			{
-				this .colorNode .addInterest ("requestRebuild",    this);
-				this .colorNode .addInterest ("set_transparent__", this);
+				this .colorNode .addInterest ("requestRebuild", this);
+				this .colorNode .transparent_ .addInterest ("set_transparent__", this);
 
 				this .set_transparent__ ();
 			}
 			else
-				this .transparent_ = false;
+				this .setTransparent (false);
 		},
 		set_transparent__: function ()
 		{
-			this .transparent_ = this .colorNode .isTransparent ();
+			this .setTransparent (this .colorNode .getTransparent ());
 		},
 		set_texCoord__: function ()
 		{
@@ -170,7 +170,7 @@ function (Fields,
 			if (this .texCoordNode)
 				this .texCoordNode .addInterest ("requestRebuild", this);
 
-			this .setCurrentTexCoord (this .texCoordNode);
+			this .setTextureCoordinate (this .texCoordNode);
 		},
 		set_normal__: function ()
 		{