x_ite 4.0.5 → 4.7.5

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

@@ -48,7 +48,6 @@
 
 
 define ([
-	"jquery",
 	"x_ite/Fields",
 	"x_ite/Basic/X3DFieldDefinition",
 	"x_ite/Basic/FieldDefinitionArray",
@@ -60,11 +59,10 @@ define ([
 	"standard/Math/Numbers/Rotation4",
 	"standard/Math/Numbers/Matrix4",
 ],
-function ($,
-          Fields,
+function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DGeometryNode, 
+          X3DGeometryNode,
           X3DConstants,
           Triangle3,
           Vector2,
@@ -74,32 +72,36 @@ function ($,
 {
 "use strict";
 
-	var
-		matrix    = new Matrix4 (),
-		rotations = [ ];
-
 	function Extrusion (executionContext)
 	{
 		X3DGeometryNode .call (this, executionContext);
 
 		this .addType (X3DConstants .Extrusion);
+
+		this .creaseAngle_  .setUnit ("angle");
+		this .crossSection_ .setUnit ("length");
+		this .spine_        .setUnit ("length");
 	}
 
-	Extrusion .prototype = $.extend (Object .create (X3DGeometryNode .prototype),
+	Extrusion .prototype = Object .assign (Object .create (X3DGeometryNode .prototype),
 	{
 		constructor: Extrusion,
 		fieldDefinitions: new FieldDefinitionArray ([
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",     new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "beginCap",     new Fields .SFBool (true)),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "endCap",       new Fields .SFBool (true)),
-			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 .inputOutput,    "crossSection", new Fields .MFVec2f (new Vector2 (1, 1), new Vector2 (1, -1), new Vector2 (-1, -1), new Vector2 (-1, 1), new Vector2 (1, 1))),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "orientation",  new Fields .MFRotation (new Rotation4 ())),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "scale",        new Fields .MFVec2f (new Vector2 (1, 1))),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "spine",        new Fields .MFVec3f (new Vector3 (0, 0, 0), new Vector3 (0, 1, 0))),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",         new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOnly,      "set_crossSection", new Fields .MFVec2f ()),
+			new X3DFieldDefinition (X3DConstants .inputOnly,      "set_orientation",  new Fields .MFRotation ()),
+			new X3DFieldDefinition (X3DConstants .inputOnly,      "set_scale",        new Fields .MFVec2f ()),
+			new X3DFieldDefinition (X3DConstants .inputOnly,      "set_spine",        new Fields .MFVec3f ()),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "beginCap",         new Fields .SFBool (true)),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "endCap",           new Fields .SFBool (true)),
+			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, "crossSection",     new Fields .MFVec2f (new Vector2 (1, 1), new Vector2 (1, -1), new Vector2 (-1, -1), new Vector2 (-1, 1), new Vector2 (1, 1))),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "orientation",      new Fields .MFRotation (new Rotation4 ())),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "scale",            new Fields .MFVec2f (new Vector2 (1, 1))),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "spine",            new Fields .MFVec3f (new Vector3 (0, 0, 0), new Vector3 (0, 1, 0))),
 		]),
 		getTypeName: function ()
 		{
@@ -113,9 +115,18 @@ function ($,
 		{
 			return "geometry";
 		},
+		initialize: function ()
+		{
+			X3DGeometryNode .prototype .initialize .call (this);
+
+			this .set_crossSection_ .addFieldInterest (this .crossSection_);
+			this .set_orientation_  .addFieldInterest (this .orientation_);
+			this .set_scale_        .addFieldInterest (this .scale_);
+			this .set_spine_        .addFieldInterest (this .spine_);
+		},
 		getClosedOrientation: function ()
 		{
-			var orientation = this .orientation_ .getValue ();
+			var orientation = this .orientation_;
 
 			if (orientation .length)
 			{
@@ -128,475 +139,550 @@ function ($,
 
 			return true;
 		},
-		createPoints: function ()
+		createPoints: (function ()
 		{
-			var
-				crossSection = this .crossSection_. getValue (),
-				orientation  = this .orientation_. getValue (),
-				scale        = this .scale_. getValue (),
-				spine        = this .spine_. getValue (),
-				points       = [ ];
+			var scale3 = new Vector3 (1, 1, 1);
 
-			// calculate SCP rotations
-
-			var rotations = this .createRotations ();
-
-			// calculate vertices.
-			
-			for (var i = 0, length = spine .length; i < length; ++ i)
+			return function ()
 			{
-				matrix .identity ();
-				matrix .translate (spine [i] .getValue ());
+				var
+					crossSection = this .crossSection_,
+					orientation  = this .orientation_,
+					scale        = this .scale_,
+					spine        = this .spine_,
+					points       = [ ];
 
-				if (orientation .length)
-					matrix .rotate (orientation [Math .min (i, orientation .length - 1)] .getValue ());
+				// calculate SCP rotations
 
-				matrix .multLeft (rotations [i]);
+				var rotations = this .createRotations ();
 
-				if (scale .length)
-				{
-					var s = scale [Math .min (i, scale .length - 1)] .getValue ();
-					matrix .scale (new Vector3 (s .x, 1, s .y));
-				}
+				// calculate vertices.
 
-				for (var cs = 0, csLength = crossSection .length; cs < csLength; ++ cs)
+				for (var i = 0, length = spine .length; i < length; ++ i)
 				{
-					var vector = crossSection [cs] .getValue ();
-					points .push (matrix .multVecMatrix (new Vector3 (vector .x, 0, vector .y)));
+					var matrix = rotations [i];
+
+					if (orientation .length)
+						matrix .rotate (orientation [Math .min (i, orientation .length - 1)] .getValue ());
+
+					if (scale .length)
+					{
+						var s = scale [Math .min (i, scale .length - 1)] .getValue ();
+						matrix .scale (scale3 .set (s .x, 1, s .y));
+					}
+
+					for (var cs = 0, csLength = crossSection .length; cs < csLength; ++ cs)
+					{
+						var vector = crossSection [cs] .getValue ();
+						points .push (matrix .multVecMatrix (new Vector3 (vector .x, 0, vector .y)));
+					}
 				}
-			}
 
-			return points;
-		},
-		createRotations: function ()
+				return points;
+			};
+		})(),
+		createRotations: (function ()
 		{
-			// calculate SCP rotations
+			var rotations = [ ];
 
 			var
-				spine       = this .spine_ .getValue (),
-				numSpines   = spine .length,
-				firstSpine  = spine [0] .getValue (),
-				lastSpine   = spine [spine .length - 1] .getValue (),
-				closedSpine = firstSpine .equals (lastSpine) && this .getClosedOrientation ();
-
-			// Extend or shrink static rotations array:
-			for (var i = rotations .length; i < numSpines; ++ i)
-				rotations [i] = new Matrix4 ();
+				SCPxAxis = new Vector3 (0, 0, 0),
+				SCPyAxis = new Vector3 (0, 0, 0),
+				SCPzAxis = new Vector3 (0, 0, 0);
 
-			rotations .length = numSpines;
+			var
+				SCPyAxisPrevious = new Vector3 (0, 0, 0),
+				SCPzAxisPrevious = new Vector3 (0, 0, 0);
 
-			// SCP axes:
 			var
-				SCPxAxis,
-				SCPyAxis,
-				SCPzAxis = new Vector3 (0, 0, 0);
+				vector3  = new Vector3 (0, 0, 0),
+				rotation = new Rotation4 (0, 0, 1, 0);
 
-			// SCP for the first point:
-			if (closedSpine)
+			return function ()
 			{
-				SCPyAxis = Vector3 .subtract (spine [1] .getValue (), spine [spine .length - 2] .getValue ()) .normalize ();
-				SCPzAxis = Vector3 .subtract (spine [1] .getValue (), spine [0] .getValue ())
-				           .cross (Vector3 .subtract (spine [spine .length - 2] .getValue (), spine [0] .getValue ()))
-				           .normalize ();
-			}
-			else
-			{
-				SCPyAxis = Vector3 .subtract (spine [1] .getValue (), spine [0] .getValue ()) .normalize ();
+				// calculate SCP rotations
 
-				// Find first defined Z-axis.
-				for (var i = 1, length = spine .length - 1; i < length; ++ i)
-				{
-					SCPzAxis = Vector3 .subtract (spine [i + 1] .getValue (), spine [i] .getValue ())
-					           .cross (Vector3 .subtract (spine [i - 1] .getValue (), spine [i] .getValue ()))
-					           .normalize ();
+				var
+					spine       = this .spine_,
+					numSpines   = spine .length,
+					firstSpine  = spine [0] .getValue (),
+					lastSpine   = spine [spine .length - 1] .getValue (),
+					closedSpine = firstSpine .equals (lastSpine) && this .getClosedOrientation ();
 
-					if (! SCPzAxis .equals (Vector3 .Zero))
-						break;
-				}
-			}
+				// Extend or shrink static rotations array:
+				for (var i = rotations .length; i < numSpines; ++ i)
+					rotations [i] = new Matrix4 ();
 
-			// The entire spine is coincident:
-			if (SCPyAxis .equals (Vector3 .Zero))
-				SCPyAxis .set (0, 1, 0);
+				rotations .length = numSpines;
 
-			// The entire spine is collinear:
-			if (SCPzAxis .equals (Vector3 .Zero))
-				SCPzAxis = new Rotation4 (new Vector3 (0, 1, 0), SCPyAxis) .multVecRot (new Vector3 (0, 0, 1));
+				// SCP axes:
+				SCPxAxis .set (0, 0, 0);
+				SCPyAxis .set (0, 0, 0);
+				SCPzAxis .set (0, 0, 0);
 
-			// We do not have to normalize SCPxAxis, as SCPyAxis and SCPzAxis are orthogonal.
-			SCPxAxis = Vector3 .cross (SCPyAxis, SCPzAxis);
+				// SCP for the first point:
+				if (closedSpine)
+				{
+					var s = firstSpine;
 
-			rotations [0] .set (SCPxAxis .x, SCPxAxis .y, SCPxAxis .z, 0,
-			                    SCPyAxis .x, SCPyAxis .y, SCPyAxis .z, 0,
-			                    SCPzAxis .x, SCPzAxis .y, SCPzAxis .z, 0,
-			                    0,           0,           0,           1);
+					// Find first defined Y-axis.
+					for (var i = 1, length = numSpines - 2; i < length; ++ i)
+					{
+						SCPyAxis .assign (spine [i] .getValue ()) .subtract (s) .normalize ()
+							.subtract (vector3 .assign (spine [length] .getValue ()) .subtract (s) .normalize ())
+							.normalize ();
 
-			// For all points other than the first or last:
+						if (! SCPyAxis .equals (Vector3 .Zero))
+							break;
+					}
 
-			var
-				SCPyAxisPrevious = SCPyAxis,
-				SCPzAxisPrevious = SCPzAxis;
+					// Find first defined Z-axis.
+					for (var i = 0, length = numSpines - 2; i < length; ++ i)
+					{
+						SCPzAxis .assign (spine [i + 1] .getValue ()) .subtract (spine [i] .getValue ())
+						           .cross (vector3 .assign (spine [length] .getValue ()) .subtract (spine [i] .getValue ()))
+						           .normalize ();
 
-			for (var i = 1, length = spine .length - 1; i < length; ++ i)
-			{
-				SCPyAxis = Vector3 .subtract (spine [i + 1] .getValue (), spine [i - 1] .getValue ()) .normalize ();
-				SCPzAxis = Vector3 .subtract (spine [i + 1] .getValue (), spine [i] .getValue ())
-				           .cross (Vector3 .subtract (spine [i - 1] .getValue (), spine [i] .getValue ()))
-				           .normalize ();
+						if (! SCPzAxis .equals (Vector3 .Zero))
+							break;
+					}
+				}
+				else
+				{
+					// Find first defined Y-axis.
+					for (var i = 0, length = numSpines - 1; i < length; ++ i)
+					{
+						SCPyAxis .assign (spine [i + 1] .getValue ()) .subtract (spine [i] .getValue ()) .normalize ();
 
-				// g.
-				if (SCPzAxisPrevious .dot (SCPzAxis) < 0)
-					SCPzAxis .negate ();
+						if (! SCPyAxis .equals (Vector3 .Zero))
+							break;
+					}
 
-				// The two points used in computing the Y-axis are coincident.
+					// Find first defined Z-axis.
+					for (var i = 1, length = numSpines - 1; i < length; ++ i)
+					{
+						SCPzAxis .assign (spine [i + 1] .getValue ()) .subtract (spine [i] .getValue ())
+						         .cross (vector3 .assign (spine [i - 1] .getValue ()) .subtract (spine [i] .getValue ()))
+						         .normalize ();
+
+						if (! SCPzAxis .equals (Vector3 .Zero))
+							break;
+					}
+				}
+
+				// The entire spine is coincident:
 				if (SCPyAxis .equals (Vector3 .Zero))
-					SCPyAxis = SCPyAxisPrevious;
-				else
-					SCPyAxisPrevious = SCPyAxis;
+					SCPyAxis .set (0, 1, 0);
 
-				// The three points used in computing the Z-axis are collinear.
+				// The entire spine is collinear:
 				if (SCPzAxis .equals (Vector3 .Zero))
-					SCPzAxis = SCPzAxisPrevious;
-				else
-					SCPzAxisPrevious = SCPzAxis;
+					rotation .setFromToVec (Vector3 .yAxis, SCPyAxis) .multVecRot (SCPzAxis .assign (Vector3 .zAxis));
 
 				// We do not have to normalize SCPxAxis, as SCPyAxis and SCPzAxis are orthogonal.
-				SCPxAxis = Vector3 .cross (SCPyAxis, SCPzAxis);
+				SCPxAxis .assign (SCPyAxis) .cross (SCPzAxis);
+
+				// Get first spine
+				var s = firstSpine;
 
-				rotations [i] .set (SCPxAxis .x, SCPxAxis .y, SCPxAxis .z, 0,
+				rotations [0] .set (SCPxAxis .x, SCPxAxis .y, SCPxAxis .z, 0,
 				                    SCPyAxis .x, SCPyAxis .y, SCPyAxis .z, 0,
 				                    SCPzAxis .x, SCPzAxis .y, SCPzAxis .z, 0,
-				                    0,           0,           0,           1);
-			}
+				                    s .x,        s .y,        s .z,        1);
 
-			// SCP for the last point
-			if (closedSpine)
-			{
-				// The SCPs for the first and last points are the same.
-				rotations [numSpines - 1] .assign (rotations [0]);
-			}
-			else
-			{
-				SCPyAxis = Vector3 .subtract (spine [spine .length - 1] .getValue (), spine [spine .length - 2] .getValue ()) .normalize ();
-				
-				if (spine .length > 2)
+				// For all points other than the first or last:
+
+				SCPyAxisPrevious .assign (SCPyAxis);
+				SCPzAxisPrevious .assign (SCPzAxis);
+
+				for (var i = 1, length = numSpines - 1; i < length; ++ i)
 				{
-					SCPzAxis = Vector3 .subtract (spine [spine .length - 1] .getValue (), spine [spine .length - 2] .getValue ())
-					           .cross (Vector3 .subtract (spine [spine .length - 3] .getValue (), spine [spine .length - 2] .getValue ()))
-					           .normalize ();
+					var s = spine [i] .getValue ();
+
+					SCPyAxis .assign (spine [i + 1] .getValue ()) .subtract (s) .normalize ()
+								.subtract (vector3 .assign (spine [i - 1] .getValue ()) .subtract (s) .normalize ())
+								.normalize ();
+					SCPzAxis .assign (spine [i + 1] .getValue ()) .subtract (s)
+					         .cross (vector3 .assign (spine [i - 1] .getValue ()) .subtract (s))
+					         .normalize ();
+
+					// g.
+					if (SCPzAxisPrevious .dot (SCPzAxis) < 0)
+						SCPzAxis .negate ();
+
+					// The two points used in computing the Y-axis are coincident.
+					if (SCPyAxis .equals (Vector3 .Zero))
+						SCPyAxis .assign (SCPyAxisPrevious);
+					else
+						SCPyAxisPrevious .assign (SCPyAxis);
+
+					// The three points used in computing the Z-axis are collinear.
+					if (SCPzAxis .equals (Vector3 .Zero))
+						SCPzAxis .assign (SCPzAxisPrevious);
+					else
+						SCPzAxisPrevious .assign (SCPzAxis);
+
+					// We do not have to normalize SCPxAxis, as SCPyAxis and SCPzAxis are orthogonal.
+					SCPxAxis .assign (SCPyAxis) .cross (SCPzAxis);
+
+					rotations [i] .set (SCPxAxis .x, SCPxAxis .y, SCPxAxis .z, 0,
+					                    SCPyAxis .x, SCPyAxis .y, SCPyAxis .z, 0,
+					                    SCPzAxis .x, SCPzAxis .y, SCPzAxis .z, 0,
+					                    s .x,        s .y,        s .z,        1);
 				}
 
-				// g.
-				if (SCPzAxisPrevious .dot (SCPzAxis) < 0)
-					SCPzAxis .negate ();
+				// SCP for the last point
+				if (closedSpine)
+				{
+					// The SCPs for the first and last points are the same.
+					rotations [numSpines - 1] .assign (rotations [0]);
+				}
+				else
+				{
+					var s = lastSpine;
 
-				// The two points used in computing the Y-axis are coincident.
-				if (SCPyAxis .equals (Vector3 .Zero))
-					SCPyAxis = SCPyAxisPrevious;
+					SCPyAxis .assign (s) .subtract (spine [numSpines - 2] .getValue ()) .normalize ();
 
-				// The three points used in computing the Z-axis are collinear.
-				if (SCPzAxis .equals (Vector3 .Zero))
-					SCPzAxis = SCPzAxisPrevious;
+					if (numSpines > 2)
+					{
+						SCPzAxis .assign (s) .subtract (spine [numSpines - 2] .getValue ())
+						         .cross (vector3 .assign (spine [numSpines - 3] .getValue ()) .subtract (spine [numSpines - 2] .getValue ()))
+						         .normalize ();
+					}
 
-				// We do not have to normalize SCPxAxis, as SCPyAxis and SCPzAxis are orthogonal.
-				SCPxAxis = Vector3 .cross (SCPyAxis, SCPzAxis);
+					// g.
+					if (SCPzAxisPrevious .dot (SCPzAxis) < 0)
+						SCPzAxis .negate ();
 
-				rotations [numSpines - 1] .set (SCPxAxis .x, SCPxAxis .y, SCPxAxis .z, 0,
-				                                SCPyAxis .x, SCPyAxis .y, SCPyAxis .z, 0,
-				                                SCPzAxis .x, SCPzAxis .y, SCPzAxis .z, 0,
-				                                0,           0,           0,           1);
-			}
+					// The two points used in computing the Y-axis are coincident.
+					if (SCPyAxis .equals (Vector3 .Zero))
+						SCPyAxis .assign (SCPyAxisPrevious);
 
-			return rotations;
-		},
-		build: function ()
+					// The three points used in computing the Z-axis are collinear.
+					if (SCPzAxis .equals (Vector3 .Zero))
+						SCPzAxis .assign (SCPzAxisPrevious);
+
+					// We do not have to normalize SCPxAxis, as SCPyAxis and SCPzAxis are orthogonal.
+					SCPxAxis .assign (SCPyAxis) .cross (SCPzAxis);
+
+					rotations [numSpines - 1] .set (SCPxAxis .x, SCPxAxis .y, SCPxAxis .z, 0,
+					                                SCPyAxis .x, SCPyAxis .y, SCPyAxis .z, 0,
+					                                SCPzAxis .x, SCPzAxis .y, SCPzAxis .z, 0,
+					                                s .x,        s .y,        s .z,        1);
+				}
+
+				return rotations;
+			};
+		})(),
+		build: (function ()
 		{
 			var
-				cw           = ! this .ccw_ .getValue (),
-				crossSection = this .crossSection_. getValue (),
-				spine        = this .spine_. getValue (),
-				texCoords    = [ ];
+				min     = new Vector2 (0, 0, 0),
+				max     = new Vector2 (0, 0, 0),
+				vector2 = new Vector2 (0, 0, 0);
 
-			if (spine .length < 2 || crossSection .length < 2)
-				return;
+			return function ()
+			{
+				var
+					cw            = ! this .ccw_ .getValue (),
+					crossSection  = this .crossSection_,
+					spine         = this .spine_,
+					numSpines     = spine .length,
+					texCoordArray = this .getTexCoords ();
 
-			this .getTexCoords () .push (texCoords);
+				if (numSpines < 2 || crossSection .length < 2)
+					return;
 
-			var crossSectionSize = crossSection .length; // This one is used only in the INDEX macro.
+				this .getMultiTexCoords () .push (texCoordArray);
 
-			function INDEX (n, k) { return n * crossSectionSize + k; }
+				var crossSectionSize = crossSection .length; // This one is used only in the INDEX macro.
 
-			var
-				firstSpine  = spine [0] .getValue (),
-				lastSpine   = spine [spine .length - 1] .getValue (),
-				closedSpine = firstSpine .equals (lastSpine) && this .getClosedOrientation ();
+				function INDEX (n, k) { return n * crossSectionSize + k; }
 
-			var
-				firstCrossSection  = crossSection [0] .getValue (),
-				lastCrossSection   = crossSection [crossSection .length - 1] .getValue (),
-				closedCrossSection = firstCrossSection .equals (lastCrossSection);
+				var
+					firstSpine  = spine [0] .getValue (),
+					lastSpine   = spine [numSpines - 1] .getValue (),
+					closedSpine = firstSpine .equals (lastSpine) && this .getClosedOrientation ();
 
-			// For caps calculation
+				var
+					firstCrossSection  = crossSection [0] .getValue (),
+					lastCrossSection   = crossSection [crossSection .length - 1] .getValue (),
+					closedCrossSection = firstCrossSection .equals (lastCrossSection);
 
-			var
-				min = crossSection [0] .getValue () .copy (),
-				max = crossSection [0] .getValue () .copy ();
+				// For caps calculation
 
-			for (var k = 1, length = crossSection .length; k < length; ++ k)
-			{
-				min .min (crossSection [k] .getValue ());
-				max .max (crossSection [k] .getValue ());
-			}
+				min .assign (crossSection [0] .getValue ());
+				max .assign (crossSection [0] .getValue ());
 
-			var
-				capSize      = Vector2 .subtract (max, min),
-				capMax       = Math .max (capSize .x, capSize .y),
-				numCapPoints = closedCrossSection ? crossSection .length - 1 : crossSection .length;
+				for (var k = 1, length = crossSection .length; k < length; ++ k)
+				{
+					min .min (crossSection [k] .getValue ());
+					max .max (crossSection [k] .getValue ());
+				}
 
-			// Create
+				var
+					capSize      = vector2 .assign (max) .subtract (min),
+					capMax       = Math .max (capSize .x, capSize .y),
+					numCapPoints = closedCrossSection ? crossSection .length - 1 : crossSection .length;
 
-			var
-				normalIndex = [ ],
-			   normals     = [ ],
-				points      = this .createPoints ();
+				// Create
 
-			for (var p = 0, length = points .length; p < length; ++ p)
-				normalIndex [p] = [ ];
+				var
+					normalIndex = [ ],
+				   normals     = [ ],
+					points      = this .createPoints ();
 
-			// Build body.
+				for (var p = 0, length = points .length; p < length; ++ p)
+					normalIndex [p] = [ ];
 
-			var
-				numCrossSection_1 = crossSection .length - 1,
-				numSpine_1        = spine .length - 1;
+				// Build body.
 
-			var
-				indexLeft  = INDEX (0, 0),
-				indexRight = INDEX (0, closedCrossSection ? 0 : numCrossSection_1);
+				var
+					normalArray = this .getNormals (),
+					vertexArray = this .getVertices ();
 
-			for (var n = 0; n < numSpine_1; ++ n)
-			{
-				for (var k = 0; k < numCrossSection_1; ++ k)
+				var
+					numCrossSection_1 = crossSection .length - 1,
+					numSpine_1        = numSpines - 1;
+
+				var
+					indexLeft  = INDEX (0, 0),
+					indexRight = INDEX (0, closedCrossSection ? 0 : numCrossSection_1);
+
+				for (var n = 0; n < numSpine_1; ++ n)
 				{
-					var
-						n1 = closedSpine && n === spine .length - 2 ? 0 : n + 1,
-						k1 = closedCrossSection && k === crossSection .length - 2 ? 0 : k + 1;
-
-					// k      k+1
-					//
-					// p4 ----- p3   n+1
-					//  |     / |
-					//  |   /   |
-					//  | /     |
-					// p1 ----- p2   n
-
-					var
-						i1 = INDEX (n,  k),
-						i2 = INDEX (n,  k1),
-						i3 = INDEX (n1, k1),
-						i4 = INDEX (n1, k),
-						p1 = points [i1],
-						p2 = points [i2],
-						p3 = points [i3],
-						p4 = points [i4],
-						l1 = p2 .distance (p3) >= 1e-7,
-						l2 = p4 .distance (p1) >= 1e-7;
-
-					if (cw)
+					for (var k = 0; k < numCrossSection_1; ++ k)
 					{
 						var
-							normal1 = Triangle3 .normal (p3, p2, p1, new Vector3 (0, 0, 0)),
-							normal2 = Triangle3 .normal (p4, p3, p1, new Vector3 (0, 0, 0));
-					}
-					else
-					{
+							n1 = closedSpine && n === numSpines - 2 ? 0 : n + 1,
+							k1 = closedCrossSection && k === crossSection .length - 2 ? 0 : k + 1;
+
+						// k      k+1
+						//
+						// p4 ----- p3   n+1
+						//  |     / |
+						//  |   /   |
+						//  | /     |
+						// p1 ----- p2   n
+
 						var
-							normal1 = Triangle3 .normal (p1, p2, p3, new Vector3 (0, 0, 0)),
-							normal2 = Triangle3 .normal (p1, p3, p4, new Vector3 (0, 0, 0));
-					}
+							i1 = INDEX (n,  k),
+							i2 = INDEX (n,  k1),
+							i3 = INDEX (n1, k1),
+							i4 = INDEX (n1, k),
+							p1 = points [i1],
+							p2 = points [i2],
+							p3 = points [i3],
+							p4 = points [i4],
+							l1 = p2 .distance (p3) >= 1e-7,
+							l2 = p4 .distance (p1) >= 1e-7;
 
-					// Merge points on the left and right side if spine is coincident for better normal generation.
-		
-					if (k == 0)
-					{
-						if (l2)
-							indexLeft = i1;
-						else
+						if (cw)
 						{
-							i1 = indexLeft;
-							p1 = points [i1];
+							var
+								normal1 = Triangle3 .normal (p3, p2, p1, new Vector3 (0, 0, 0)),
+								normal2 = Triangle3 .normal (p4, p3, p1, new Vector3 (0, 0, 0));
 						}
-					}
-		
-					if (k == crossSection .length - 2)
-					{
-						if (l1)
-							indexRight = i2;
 						else
 						{
-							i3 = indexRight;
-							p3 = points [i3];
+							var
+								normal1 = Triangle3 .normal (p1, p2, p3, new Vector3 (0, 0, 0)),
+								normal2 = Triangle3 .normal (p1, p3, p4, new Vector3 (0, 0, 0));
 						}
-					}
 
-					// If there are coincident spine points then one length can be zero.
+						// Merge points on the left and right side if spine is coincident for better normal generation.
 
-					// Triangle one
-
-					if (l1)
-					{
-						// p1
-						if (l2)
-							texCoords .push (k / numCrossSection_1, n / numSpine_1, 0, 1);
-						else
+						if (k == 0)
 						{
-							// Cone case: ((texCoord1 + texCoord4) / 2)
-							var y = (n / numSpine_1 + (n + 1) / numSpine_1) / 2;
+							if (l2)
+								indexLeft = i1;
+							else
+							{
+								i1 = indexLeft;
+								p1 = points [i1];
+							}
+						}
 
-							texCoords .push (k / numCrossSection_1, y, 0, 1);
+						if (k == crossSection .length - 2)
+						{
+							if (l1)
+								indexRight = i2;
+							else
+							{
+								i3 = indexRight;
+								p3 = points [i3];
+							}
 						}
 
-						normalIndex [i1] .push (normals .length);
-						normals .push (normal1);
-						this .addVertex (p1);
-	
-						// p2
-						texCoords .push ((k + 1) / numCrossSection_1, n / numSpine_1, 0, 1);
-						normalIndex [i2] .push (normals .length);
-						normals .push (normal1);
-						this .addVertex (p2);
-	
-						// p3
-						texCoords .push ((k + 1) / numCrossSection_1, (n + 1) / numSpine_1, 0, 1);
-						normalIndex [i3] .push (normals .length);
-						normals .push (normal1);
-						this .addVertex (p3);
-					}
+						// If there are coincident spine points then one length can be zero.
 
-					// Triangle two
+						// Triangle one
 
-					if (l2)
-					{
-						// p1
-						texCoords .push (k / numCrossSection_1, n / numSpine_1, 0, 1);
-						normalIndex [i1] .push (normals .length);
-						normals .push (normal2);
-						this .addVertex (p1);
-	
-						// p3
 						if (l1)
-							texCoords .push ((k + 1) / numCrossSection_1, (n + 1) / numSpine_1, 0, 1);
-						else
 						{
-							// Cone case: ((texCoord3 + texCoord2) / 2)
-							var y = ((n + 1) / numSpine_1 + n / numSpine_1) / 2;
-
-							texCoords .push ((k + 1) / numCrossSection_1, y, 0, 1);
+							// p1
+							if (l2)
+								texCoordArray .push (k / numCrossSection_1, n / numSpine_1, 0, 1);
+							else
+							{
+								// Cone case: ((texCoord1 + texCoord4) / 2)
+								var y = (n / numSpine_1 + (n + 1) / numSpine_1) / 2;
+
+								texCoordArray .push (k / numCrossSection_1, y, 0, 1);
+							}
+
+							normalIndex [i1] .push (normals .length);
+							normals .push (normal1);
+							vertexArray .push (p1 .x, p1 .y, p1 .z, 1);
+
+							// p2
+							texCoordArray .push ((k + 1) / numCrossSection_1, n / numSpine_1, 0, 1);
+							normalIndex [i2] .push (normals .length);
+							normals .push (normal1);
+							vertexArray .push (p2 .x, p2 .y, p2 .z, 1);
+
+							// p3
+							texCoordArray .push ((k + 1) / numCrossSection_1, (n + 1) / numSpine_1, 0, 1);
+							normalIndex [i3] .push (normals .length);
+							normals .push (normal1);
+							vertexArray .push (p3 .x, p3 .y, p3 .z, 1);
 						}
 
-						normalIndex [i3] .push (normals .length);
-						normals .push (normal2);
-						this .addVertex (p3);
-	
-						// p4
-						texCoords .push (k / numCrossSection_1, (n + 1) / numSpine_1, 0, 1);
-						normalIndex [i4] .push (normals .length);
-						normals .push (normal2);
-						this .addVertex (p4);
+						// Triangle two
+
+						if (l2)
+						{
+							// p1
+							texCoordArray .push (k / numCrossSection_1, n / numSpine_1, 0, 1);
+							normalIndex [i1] .push (normals .length);
+							normals .push (normal2);
+							vertexArray .push (p1 .x, p1 .y, p1 .z, 1);
+
+							// p3
+							if (l1)
+								texCoordArray .push ((k + 1) / numCrossSection_1, (n + 1) / numSpine_1, 0, 1);
+							else
+							{
+								// Cone case: ((texCoord3 + texCoord2) / 2)
+								var y = ((n + 1) / numSpine_1 + n / numSpine_1) / 2;
+
+								texCoordArray .push ((k + 1) / numCrossSection_1, y, 0, 1);
+							}
+
+							normalIndex [i3] .push (normals .length);
+							normals .push (normal2);
+							vertexArray .push (p3 .x, p3 .y, p3 .z, 1);
+
+							// p4
+							texCoordArray .push (k / numCrossSection_1, (n + 1) / numSpine_1, 0, 1);
+							normalIndex [i4] .push (normals .length);
+							normals .push (normal2);
+							vertexArray .push (p4 .x, p4 .y, p4 .z, 1);
+						}
 					}
 				}
-			}
 
-			// Refine body normals and add them.
+				// Refine body normals and add them.
 
-			normals = this .refineNormals (normalIndex, normals, this .creaseAngle_ .getValue ());
+				normals = this .refineNormals (normalIndex, normals, this .creaseAngle_ .getValue ());
 
-			for (var i = 0; i < normals .length; ++ i)
-				this .addNormal (normals [i]);
+				for (var i = 0; i < normals .length; ++ i)
+				{
+					var normal = normals [i];
 
-			// Build caps
+					normalArray .push (normal .x, normal .y, normal .z);
+				}
 
-			if (capMax && crossSection .length > 2)
-			{
-				if (this .beginCap_ .getValue ())
-				{
-					var
-						j         = 0, // spine
-						polygon   = [ ],
-						triangles = [ ];
+				// Build caps
 
-					for (var k = 0; k < numCapPoints; ++ k)
+				if (capMax && numCapPoints > 2)
+				{
+					if (this .beginCap_ .getValue ())
 					{
 						var
-							index = INDEX (j, numCapPoints - 1 - k),
-							point = points [index] .copy ();
-						point .index    = index;
-						point .texCoord = Vector2 .subtract (crossSection [numCapPoints - 1 - k] .getValue (), min) .divide (capMax);
-						polygon .push (point);
-					}
+							j         = 0, // spine
+							polygon   = [ ],
+							triangles = [ ];
 
-					if (this .convex_ .getValue ())
-						Triangle3 .triangulateConvexPolygon (polygon, triangles);
+						for (var k = 0; k < numCapPoints; ++ k)
+						{
+							var
+								index = INDEX (j, numCapPoints - 1 - k),
+								point = points [index] .copy ();
 
-					else
-						Triangle3 .triangulatePolygon (polygon, triangles);
+							point .index    = index;
+							point .texCoord = Vector2 .subtract (crossSection [numCapPoints - 1 - k] .getValue (), min) .divide (capMax);
+							polygon .push (point);
+						}
 
-					if (triangles .length >= 3)
-					{
-						var normal = Triangle3 .normal (points [triangles [0] .index],
-						                                points [triangles [1] .index],
-						                                points [triangles [2] .index],
-						                                new Vector3 (0, 0, 0));
+						if (this .convex_ .getValue ())
+							Triangle3 .triangulateConvexPolygon (polygon, triangles);
 
-						if (cw)
-							normal .negate ();
+						else
+							Triangle3 .triangulatePolygon (polygon, triangles);
 
-						this .addCap (texCoords, normal, points, triangles);
-					}
-				}
+						if (triangles .length >= 3)
+						{
+							var normal = Triangle3 .normal (points [triangles [0] .index],
+							                                points [triangles [1] .index],
+							                                points [triangles [2] .index],
+							                                new Vector3 (0, 0, 0));
 
-				if (this .endCap_ .getValue ())
-				{
-					var
-						j         = spine .length - 1, // spine
-						polygon   = [ ],
-						triangles = [ ];
+							if (cw)
+								normal .negate ();
 
-					for (var k = 0; k < numCapPoints; ++ k)
+							this .addCap (texCoordArray, normal, points, triangles);
+						}
+					}
+
+					if (this .endCap_ .getValue ())
 					{
 						var
-							index = INDEX (j, k),
-							point = points [index] .copy ();
-						point .index    = index;
-						point .texCoord = Vector2 .subtract (crossSection [k] .getValue (), min) .divide (capMax);
-						polygon .push (point);
-					}
+							j         = numSpines - 1, // spine
+							polygon   = [ ],
+							triangles = [ ];
 
-					if (this .convex_ .getValue ())
-						Triangle3 .triangulateConvexPolygon (polygon, triangles);
+						for (var k = 0; k < numCapPoints; ++ k)
+						{
+							var
+								index = INDEX (j, k),
+								point = points [index] .copy ();
 
-					else
-						Triangle3 .triangulatePolygon (polygon, triangles);
+							point .index    = index;
+							point .texCoord = Vector2 .subtract (crossSection [k] .getValue (), min) .divide (capMax);
+							polygon .push (point);
+						}
 
-					if (triangles .length >= 3)
-					{
-						var normal = Triangle3 .normal (points [triangles [0] .index],
-						                                points [triangles [1] .index],
-						                                points [triangles [2] .index],
-						                                new Vector3 (0, 0, 0));
+						if (this .convex_ .getValue ())
+							Triangle3 .triangulateConvexPolygon (polygon, triangles);
 
-						if (cw)
-							normal .negate ();
+						else
+							Triangle3 .triangulatePolygon (polygon, triangles);
+
+						if (triangles .length >= 3)
+						{
+							var normal = Triangle3 .normal (points [triangles [0] .index],
+							                                points [triangles [1] .index],
+							                                points [triangles [2] .index],
+							                                new Vector3 (0, 0, 0));
 
-						this .addCap (texCoords, normal, points, triangles);
+							if (cw)
+								normal .negate ();
+
+							this .addCap (texCoordArray, normal, points, triangles);
+						}
 					}
 				}
-			}
 
-			this .setSolid (this .solid_ .getValue ());
-			this .setCCW (this .ccw_ .getValue ());
-		},
-		addCap: function (texCoords, normal, vertices, triangles)
+				this .setSolid (this .solid_ .getValue ());
+				this .setCCW (this .ccw_ .getValue ());
+			};
+		})(),
+		addCap: function (texCoordArray, normal, vertices, triangles)
 		{
+			var
+				normalArray = this .getNormals (),
+				vertexArray = this .getVertices ();
+
 			for (var i = 0; i < triangles .length; i += 3)
 			{
 				var
@@ -607,22 +693,20 @@ function ($,
 					t1 = triangles [i + 1] .texCoord,
 					t2 = triangles [i + 2] .texCoord;
 
-				texCoords .push (t0 .x, t0 .y, 0, 1);
-				texCoords .push (t1 .x, t1 .y, 0, 1);
-				texCoords .push (t2 .x, t2 .y, 0, 1);
-
-				this .addNormal (normal);
-				this .addNormal (normal);
-				this .addNormal (normal);
-				
-				this .addVertex (p0);
-				this .addVertex (p1);
-				this .addVertex (p2);
+				texCoordArray .push (t0 .x, t0 .y, 0, 1);
+				texCoordArray .push (t1 .x, t1 .y, 0, 1);
+				texCoordArray .push (t2 .x, t2 .y, 0, 1);
+
+				normalArray .push (normal .x, normal .y, normal .z,
+				                   normal .x, normal .y, normal .z,
+				                   normal .x, normal .y, normal .z);
+
+				vertexArray .push (p0 .x, p0 .y, p0 .z, 1,
+				                   p1 .x, p1 .y, p1 .z, 1,
+				                   p2 .x, p2 .y, p2 .z, 1);
 			}
 		},
 	});
 
 	return Extrusion;
 });
-
-