x_ite 4.0.5 → 4.7.5

package/src/x_ite/Components/NURBS/NurbsPositionInterpolator.js

@@ -48,19 +48,25 @@
 
 
 define ([
-	"jquery",
 	"x_ite/Fields",
 	"x_ite/Basic/X3DFieldDefinition",
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/Core/X3DChildNode",
+	"x_ite/Components/Interpolation/PositionInterpolator",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Bits/X3DCast",
+	"x_ite/Browser/NURBS/NURBS",
+	"nurbs",
 ],
-function ($,
-          Fields,
+function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DChildNode, 
-          X3DConstants)
+          X3DChildNode,
+          PositionInterpolator,
+          X3DConstants,
+          X3DCast,
+          NURBS,
+          nurbs)
 {
 "use strict";
 
@@ -69,18 +75,27 @@ function ($,
 		X3DChildNode .call (this, executionContext);
 
 		this .addType (X3DConstants .NurbsPositionInterpolator);
+
+		this .addChildObjects ("rebuild", new Fields .SFTime ());
+
+	   this .interpolator  = new PositionInterpolator (executionContext);
+		this .knots         = [ ];
+		this .weights       = [ ];
+		this .controlPoints = [ ];
+		this .mesh          = { };
+		this .sampleOptions = { resolution: [ 128 ] };
 	}
 
-	NurbsPositionInterpolator .prototype = $.extend (Object .create (X3DChildNode .prototype),
+	NurbsPositionInterpolator .prototype = Object .assign (Object .create (X3DChildNode .prototype),
 	{
 		constructor: NurbsPositionInterpolator,
 		fieldDefinitions: new FieldDefinitionArray ([
 			new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",      new Fields .SFNode ()),
 			new X3DFieldDefinition (X3DConstants .inputOnly,   "set_fraction",  new Fields .SFFloat ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "controlPoint",  new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "knot",          new Fields .MFDouble ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "order",         new Fields .SFInt32 (3)),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "knot",          new Fields .MFDouble ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "weight",        new Fields .MFDouble ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "controlPoint",  new Fields .SFNode ()),
 			new X3DFieldDefinition (X3DConstants .outputOnly,  "value_changed", new Fields .SFVec3f ()),
 		]),
 		getTypeName: function ()
@@ -95,9 +110,109 @@ function ($,
 		{
 			return "children";
 		},
+		initialize: function ()
+		{
+			X3DChildNode .prototype .initialize .call (this);
+
+			this .order_        .addInterest ("requestRebuild",     this);
+			this .knot_         .addInterest ("requestRebuild",     this);
+			this .weight_       .addInterest ("requestRebuild",     this);
+			this .controlPoint_ .addInterest ("set_controlPoint__", this);
+
+			this .rebuild_ .addInterest ("build", this);
+
+			this .set_fraction_ .addFieldInterest (this .interpolator .set_fraction_);
+			this .interpolator .value_changed_ .addFieldInterest (this .value_changed_);
+
+			this .interpolator .setup ();
+
+			this .set_controlPoint__ ();
+		},
+		set_controlPoint__: function ()
+		{
+			if (this .controlPointNode)
+				this .controlPointNode .removeInterest ("requestRebuild", this);
+
+			this .controlPointNode = X3DCast (X3DConstants .X3DCoordinateNode, this .controlPoint_);
+
+			if (this .controlPointNode)
+				this .controlPointNode .addInterest ("requestRebuild", this);
+
+			this .requestRebuild ();
+		},
+		getClosed: function (order, knot, weight, controlPointNode)
+		{
+			return false && NURBS .getClosed (order, knot, weight, controlPointNode);
+		},
+		getKnots: function (result, closed, order, dimension, knot)
+		{
+			return NURBS .getKnots (result, closed, order, dimension, knot);
+		},
+		getWeights: function (result, dimension, weight)
+		{
+			return NURBS .getWeights (result, dimension, weight);
+		},
+		getControlPoints: function (result, closed, order, weights, controlPointNode)
+		{
+			return NURBS .getControlPoints (result, closed, order, weights, controlPointNode);
+		},
+		requestRebuild: function ()
+		{
+			this .rebuild_ .addEvent ();
+		},
+		build: function ()
+		{
+			if (this .order_ .getValue () < 2)
+				return;
+
+			if (! this .controlPointNode)
+				return;
+
+			if (this .controlPointNode .getSize () < this .order_ .getValue ())
+				return;
+
+			// Order and dimension are now positive numbers.
+
+			var
+				closed        = this .getClosed (this .order_ .getValue (), this .knot_, this .weight_, this .controlPointNode),
+				weights       = this .getWeights (this .weights, this .controlPointNode .getSize (), this .weight_),
+				controlPoints = this .getControlPoints (this .controlPoints, closed, this .order_ .getValue (), weights, this .controlPointNode);
+
+			// Knots
+
+			var
+				knots = this .getKnots (this .knots, closed, this .order_ .getValue (), this .controlPointNode .getSize (), this .knot_),
+				scale = knots .at (-1) - knots [0];
+
+			// Initialize NURBS tessellator
+
+			var degree = this .order_ .getValue () - 1;
+
+			var surface = this .surface = (this .surface || nurbs) ({
+				boundary: ["open"],
+				degree: [degree],
+				knots: [knots],
+				points: controlPoints,
+				debug: false,
+			});
+
+			this .sampleOptions .haveWeights = Boolean (weights);
+
+			var
+				mesh         = nurbs .sample (this .mesh, surface, this .sampleOptions),
+				points       = mesh .points,
+				interpolator = this .interpolator;
+
+			interpolator .key_      .length = 0;
+			interpolator .keyValue_ .length = 0;
+
+			for (var i = 0, length = points .length; i < length; i += 3)
+			{
+				interpolator .key_      .push (knots [0] + i / (length - 3) * scale);
+				interpolator .keyValue_. push (new Fields .SFVec3f (points [i], points [i + 1], points [i + 2]));
+			}
+		},
 	});
 
 	return NurbsPositionInterpolator;
 });
-
-

package/src/x_ite/Components/NURBS/NurbsSet.js

@@ -48,43 +48,60 @@
 
 
 define ([
-	"jquery",
 	"x_ite/Fields",
 	"x_ite/Basic/X3DFieldDefinition",
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/Core/X3DChildNode",
 	"x_ite/Components/Grouping/X3DBoundedObject",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Bits/X3DCast",
 ],
-function ($,
-          Fields,
+function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DChildNode, 
-          X3DBoundedObject, 
-          X3DConstants)
+          X3DChildNode,
+          X3DBoundedObject,
+          X3DConstants,
+          X3DCast)
 {
 "use strict";
 
+	function remove (array, first, last, range, rfirst, rlast)
+	{
+		var set = { };
+
+		for (var i = rfirst; i < rlast; ++ i)
+			set [getId (range [i])] = true;
+
+		function compare (value) { return set [getId (value)]; }
+
+		return array .remove (first, last, compare);
+	}
+
 	function NurbsSet (executionContext)
 	{
-		X3DChildNode .call (this, executionContext);
+		X3DChildNode     .call (this, executionContext);
 		X3DBoundedObject .call (this, executionContext);
 
 		this .addType (X3DConstants .NurbsSet);
+
+		this .geometryNodes = [ ];
 	}
 
-	NurbsSet .prototype = $.extend (Object .create (X3DChildNode .prototype),new X3DBoundedObject (),
+	NurbsSet .prototype = Object .assign (Object .create (X3DChildNode .prototype),
+		X3DBoundedObject .prototype,
 	{
 		constructor: NurbsSet,
 		fieldDefinitions: new FieldDefinitionArray ([
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",          new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "tessellationScale", new Fields .SFFloat (1)),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "visible",           new Fields .SFBool (true)),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "bboxDisplay",       new Fields .SFBool ()),
 			new X3DFieldDefinition (X3DConstants .initializeOnly, "bboxSize",          new Fields .SFVec3f (-1, -1, -1)),
 			new X3DFieldDefinition (X3DConstants .initializeOnly, "bboxCenter",        new Fields .SFVec3f ()),
 			new X3DFieldDefinition (X3DConstants .inputOnly,      "addGeometry",       new Fields .MFNode ()),
 			new X3DFieldDefinition (X3DConstants .inputOnly,      "removeGeometry",    new Fields .MFNode ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "geometry",          new Fields .MFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "tessellationScale", new Fields .SFFloat (1)),
 		]),
 		getTypeName: function ()
 		{
@@ -98,9 +115,73 @@ function ($,
 		{
 			return "children";
 		},
+		initialize: function ()
+		{
+			X3DChildNode     .prototype .initialize .call (this);
+			X3DBoundedObject .prototype .initialize .call (this);
+
+			this .tessellationScale_ .addInterest ("set_tessellationScale__", this);
+			this .addGeometry_       .addInterest ("set_addGeometry__",       this);
+			this .removeGeometry_    .addInterest ("set_removeGeometry__",    this);
+			this .geometry_          .addInterest ("set_geometry__",          this);
+
+			this .set_geometry__ ();
+		},
+		getBBox: function (bbox, shadow)
+		{
+			// Add bounding boxes
+
+			for (var i = 0, length = this .geometryNodes .length; i < length; ++ i)
+			{
+				bbox .add (this .geometryNodes [i] .getBBox ());
+			}
+
+			return bbox;
+		},
+		set_tessellationScale__: function ()
+		{
+			var tessellationScale = Math .max (0, this .tessellationScale_ .getValue ());
+
+			for (var i = 0, length = this .geometryNodes .length; i < length; ++ i)
+				this .geometryNodes [i] .setTessellationScale (tessellationScale);
+		},
+		set_addGeometry__: function ()
+		{
+			this .addGeometry_ .setTainted (true);
+
+			this .addGeometry_ .erase (remove (this .addGeometry_, 0, this .addGeometry_ .length,
+			                                   this .geometry_, 0, this .geometry_ .length),
+			                           this .addGeometry_ .length);
+
+			for (var i = 0, length = this .addGeometry_ .length; i < length; ++ i)
+				this .geometry_ .push (this .addGeometry_ [i]);
+
+			this .addGeometry_ .setTainted (false);
+		},
+		set_removeGeometry__: function ()
+		{
+			this .geometry_ .erase (remove (this .geometry_,       0, this .geometry_ .length,
+			                                this .removeGeometry_, 0, this .removeGeometry_ .length),
+			                        this .geometry__ .length);
+		},
+		set_geometry__: function ()
+		{
+			for (var i = 0, length = this .geometryNodes .length; i < length; ++ i)
+				this .geometryNodes [i] .setTessellationScale (1);
+
+			this .geometryNodes .length = 0;
+
+			for (var i = 0, length = this .geometry_ .length; i < length; ++ i)
+			{
+				var geometryNode = X3DCast (X3DConstants .X3DNurbsSurfaceGeometryNode, this .geometry_ [i]);
+
+				if (geometryNode)
+					this .geometryNodes .push (geometryNode);
+			}
+
+			this .set_tessellationScale__ ();
+		},
 	});
 
 	return NurbsSet;
 });
-
-

package/src/x_ite/Components/NURBS/NurbsSurfaceInterpolator.js

@@ -48,19 +48,25 @@
 
 
 define ([
-	"jquery",
 	"x_ite/Fields",
 	"x_ite/Basic/X3DFieldDefinition",
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/Core/X3DChildNode",
+	"x_ite/Components/NURBS/NurbsPatchSurface",
 	"x_ite/Bits/X3DConstants",
+	"standard/Math/Geometry/Line3",
+	"standard/Math/Geometry/Triangle2",
+	"standard/Math/Numbers/Vector3",
 ],
-function ($,
-          Fields,
+function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
           X3DChildNode, 
-          X3DConstants)
+          NurbsPatchSurface, 
+          X3DConstants,
+          Line3,
+          Triangle2,
+          Vector3)
 {
 "use strict";
 
@@ -69,24 +75,26 @@ function ($,
 		X3DChildNode .call (this, executionContext);
 
 		this .addType (X3DConstants .NurbsSurfaceInterpolator);
+
+		this .geometry = new NurbsPatchSurface (executionContext);
 	}
 
-	NurbsSurfaceInterpolator .prototype = $.extend (Object .create (X3DChildNode .prototype),
+	NurbsSurfaceInterpolator .prototype = Object .assign (Object .create (X3DChildNode .prototype),
 	{
 		constructor: NurbsSurfaceInterpolator,
 		fieldDefinitions: new FieldDefinitionArray ([
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",         new Fields .SFNode ()),
 			new X3DFieldDefinition (X3DConstants .inputOnly,      "set_fraction",     new Fields .SFVec2f ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "controlPoint",     new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "weight",           new Fields .MFDouble ()),
-			new X3DFieldDefinition (X3DConstants .outputOnly,     "position_changed", new Fields .SFVec3f ()),
-			new X3DFieldDefinition (X3DConstants .outputOnly,     "normal_changed",   new Fields .SFVec3f ()),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "uDimension",       new Fields .SFInt32 ()),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "uKnot",            new Fields .MFDouble ()),
 			new X3DFieldDefinition (X3DConstants .initializeOnly, "uOrder",           new Fields .SFInt32 (3)),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "vOrder",           new Fields .SFInt32 (3)),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "uDimension",       new Fields .SFInt32 ()),
 			new X3DFieldDefinition (X3DConstants .initializeOnly, "vDimension",       new Fields .SFInt32 ()),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "uKnot",            new Fields .MFDouble ()),
 			new X3DFieldDefinition (X3DConstants .initializeOnly, "vKnot",            new Fields .MFDouble ()),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "vOrder",           new Fields .SFInt32 (3)),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "weight",           new Fields .MFDouble ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "controlPoint",     new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .outputOnly,     "normal_changed",   new Fields .SFVec3f ()),
+			new X3DFieldDefinition (X3DConstants .outputOnly,     "position_changed", new Fields .SFVec3f ()),
 		]),
 		getTypeName: function ()
 		{
@@ -100,6 +108,82 @@ function ($,
 		{
 			return "children";
 		},
+		initialize: function ()
+		{
+			this .set_fraction_ .addInterest ("set_fraction__", this);
+
+			this .uOrder_       .addFieldInterest (this .geometry .uOrder_);
+			this .vOrder_       .addFieldInterest (this .geometry .vOrder_);
+			this .uDimension_   .addFieldInterest (this .geometry .uDimension_);
+			this .vDimension_   .addFieldInterest (this .geometry .vDimension_);
+			this .uKnot_        .addFieldInterest (this .geometry .uKnot_);
+			this .vKnot_        .addFieldInterest (this .geometry .vKnot_);
+			this .weight_       .addFieldInterest (this .geometry .weight_);
+			this .controlPoint_ .addFieldInterest (this .geometry .controlPoint_);
+
+			this .geometry .uTessellation_ = 128;
+			this .geometry .vTessellation_ = 128;
+			this .geometry .uOrder_        = this .uOrder_;
+			this .geometry .vOrder_        = this .vOrder_;
+			this .geometry .uDimension_    = this .uDimension_;
+			this .geometry .vDimension_    = this .vDimension_;
+			this .geometry .uKnot_         = this .uKnot_;
+			this .geometry .vKnot_         = this .vKnot_;
+			this .geometry .weight_        = this .weight_;
+			this .geometry .controlPoint_  = this .controlPoint_;
+
+			this .geometry .setup ();
+		},
+		set_fraction__: (function ()
+		{
+			var
+				a     = new Vector3 (0, 0, 0),
+				b     = new Vector3 (0, 0, 0),
+				c     = new Vector3 (0, 0, 0),
+				point = new Vector3 (0, 0, 0),
+				line  = new Line3 (Vector3 .Zero, Vector3 .zAxis),
+				uvt   = { };
+
+			return function ()
+			{
+				var
+					fraction       = this .set_fraction_ .getValue (),
+					texCoordsArray = this .geometry .getTexCoords (),
+					normalArray    = this .geometry .getNormals (),
+					verticesArray  = this .geometry .getVertices ();
+	
+				for (var i4 = 0, i3 = 0, length = texCoordsArray .length; i4 < length; i4 += 12, i3 += 9)
+				{
+					a .set (texCoordsArray [i4 + 0], texCoordsArray [i4 + 1], 0);
+					b .set (texCoordsArray [i4 + 4], texCoordsArray [i4 + 5], 0);
+					c .set (texCoordsArray [i4 + 7], texCoordsArray [i4 + 9], 0);
+	
+					if (Triangle2 .isPointInTriangle (a, b, c, fraction))
+					{
+						line .set (point .set (fraction .x, fraction .y, 0), Vector3 .zAxis);
+
+						if (line .intersectsTriangle (a, b, c, uvt))
+						{
+							var
+								u = uvt .u,
+								v = uvt .v,
+								t = uvt .t;
+
+							var normal = new Vector3 (t * normalArray [i3 + 0] + u * normalArray [i3 + 3] + v * normalArray [i3 + 6],
+							                          t * normalArray [i3 + 1] + u * normalArray [i3 + 4] + v * normalArray [i3 + 7],
+							                          t * normalArray [i3 + 2] + u * normalArray [i3 + 5] + v * normalArray [i3 + 8]);
+
+							var position = new Vector3 (t * verticesArray [i4 + 0] + u * verticesArray [i4 + 4] + v * verticesArray [i4 +  8],
+							                            t * verticesArray [i4 + 1] + u * verticesArray [i4 + 5] + v * verticesArray [i4 +  9],
+							                            t * verticesArray [i4 + 2] + u * verticesArray [i4 + 6] + v * verticesArray [i4 + 10]);
+
+							this .normal_changed_   = normal;
+							this .position_changed_ = position;
+						}
+					}
+				}
+			};
+		})(),
 	});
 
 	return NurbsSurfaceInterpolator;

package/src/x_ite/Components/NURBS/NurbsSweptSurface.js

@@ -48,19 +48,21 @@
 
 
 define ([
-	"jquery",
 	"x_ite/Fields",
 	"x_ite/Basic/X3DFieldDefinition",
 	"x_ite/Basic/FieldDefinitionArray",
+	"x_ite/Components/Geometry3D/Extrusion",
 	"x_ite/Components/NURBS/X3DParametricGeometryNode",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Bits/X3DCast",
 ],
-function ($,
-          Fields,
+function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
+          Extrusion, 
           X3DParametricGeometryNode, 
-          X3DConstants)
+          X3DConstants,
+          X3DCast)
 {
 "use strict";
 
@@ -69,17 +71,19 @@ function ($,
 		X3DParametricGeometryNode .call (this, executionContext);
 
 		this .addType (X3DConstants .NurbsSweptSurface);
+
+		this .extrusion = new Extrusion (executionContext);
 	}
 
-	NurbsSweptSurface .prototype = $.extend (Object .create (X3DParametricGeometryNode .prototype),
+	NurbsSweptSurface .prototype = Object .assign (Object .create (X3DParametricGeometryNode .prototype),
 	{
 		constructor: NurbsSweptSurface,
 		fieldDefinitions: new FieldDefinitionArray ([
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",          new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "crossSectionCurve", new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "trajectoryCurve",   new Fields .SFNode ()),
 			new X3DFieldDefinition (X3DConstants .initializeOnly, "solid",             new Fields .SFBool (true)),
 			new X3DFieldDefinition (X3DConstants .initializeOnly, "ccw",               new Fields .SFBool (true)),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "crossSectionCurve", new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "trajectoryCurve",   new Fields .SFNode ()),
 		]),
 		getTypeName: function ()
 		{
@@ -93,6 +97,83 @@ function ($,
 		{
 			return "geometry";
 		},
+		initialize: function ()
+		{
+			X3DParametricGeometryNode .prototype .initialize .call (this);
+
+			this .crossSectionCurve_ .addInterest ("set_crossSectionCurve__", this);
+			this .trajectoryCurve_   .addInterest ("set_trajectoryCurve__",   this);
+
+			var extrusion = this .extrusion;
+
+			extrusion .beginCap_     = false;
+			extrusion .endCap_       = false;
+			extrusion .solid_        = true;
+			extrusion .ccw_          = true;
+			extrusion .convex_       = true;
+			extrusion .creaseAngle_  = Math .PI;
+
+			extrusion .setup ();
+
+			extrusion .crossSection_ .setTainted (true);
+			extrusion .spine_        .setTainted (true);
+
+			this .set_crossSectionCurve__ ();
+			this .set_trajectoryCurve__ ();
+		},
+		set_crossSectionCurve__: function ()
+		{
+			if (this .crossSectionCurveNode)
+				this .crossSectionCurveNode .removeInterest ("requestRebuild", this);
+
+			this .crossSectionCurveNode = X3DCast (X3DConstants .X3DNurbsControlCurveNode, this .crossSectionCurve_);
+
+			if (this .crossSectionCurveNode)
+				this .crossSectionCurveNode .addInterest ("requestRebuild", this);
+		},
+		set_trajectoryCurve__: function ()
+		{
+			if (this .trajectoryCurveNode)
+				this .trajectoryCurveNode .rebuild_ .removeInterest ("requestRebuild", this);
+
+			this .trajectoryCurveNode = X3DCast (X3DConstants .NurbsCurve, this .trajectoryCurve_);
+
+			if (this .trajectoryCurveNode)
+				this .trajectoryCurveNode .rebuild_ .addInterest ("requestRebuild", this);
+		},
+		build: function ()
+		{
+			if (! this .crossSectionCurveNode)
+				return;
+		
+			if (! this .trajectoryCurveNode)
+				return;
+
+			var extrusion = this .extrusion;
+
+			extrusion .crossSection_ = this .crossSectionCurveNode .tessellate (0);
+			extrusion .spine_        = this .trajectoryCurveNode   .tessellate (0);
+
+			extrusion .rebuild ();
+
+			this .getColors ()    .assign (extrusion .getColors ());
+			this .getTexCoords () .assign (extrusion .getTexCoords ());
+			this .getNormals ()   .assign (extrusion .getNormals ());
+			this .getVertices ()  .assign (extrusion .getVertices ());
+
+			this .getMultiTexCoords () .push (this .getTexCoords ());
+
+			if (! this .ccw_ .getValue ())
+			{
+				var normals = this .getNormals ();
+
+				for (var i = 0, length = normals .length; i < length; ++ i)
+					normals [i] = -normals [i];
+			}
+
+			this .setSolid (this .solid_ .getValue ());
+			this .setCCW (this .ccw_ .getValue ());
+		},
 	});
 
 	return NurbsSweptSurface;