X-Git-Url: http://git.scottworley.com/nt3d/blobdiff_plain/1a18e646fe84c30984a5298c284d959e925e6a54..08c25ec8473e43e82a1291a528f8332239581483:/nt3d.js?ds=inline

diff --git a/nt3d.js b/nt3d.js
index 0443913..9b09b09 100644
--- a/nt3d.js
+++ b/nt3d.js
@@ -62,8 +62,22 @@ nt3d = {
 		return this.closed_trianglefan([apex].concat(base)).concat(
 		       this.trianglefan(base.reverse()));
 	},
-	extrude: function(shape, path, shapenormals, pathnormals) {
-		var guts_result = nt3d._extrude_guts(shape, path, shapenormals, pathnormals);
+	to_function: function(thing, make_indexer) {
+		// If thing is a point, just yield thing every time.
+		// If thing is a list of points && make_indexer, index into thing.
+		// If thing is already a function, just return it.
+		if (({}).toString.call(thing) === "[object Function]") {
+			return thing;  // Already a function
+		}
+		if (make_indexer && Array.isArray(thing[0])) {
+			// Looks like a list of points.
+			return function(i) { return thing[i]; }
+		}
+		return function() { return thing; }
+	},
+	extrude: function(path, shape, shapenormals, pathnormals) {
+
+		var guts_result = nt3d._extrude_guts(path, shape, shapenormals, pathnormals);
 		// Add the end-caps
 		// XXX: This doesn't work if shape is not convex
 		return guts_result.points.concat(
@@ -71,46 +85,53 @@ nt3d = {
 			nt3d.trianglefan(guts_result.last_loop));
 
 	},
-	closed_extrude: function(shape, path, shapenormals, pathnormals) {
-		var guts_result = nt3d._extrude_guts(shape, path, shapenormals, pathnormals);
+	closed_extrude: function(path, shape, shapenormals, pathnormals) {
+		var guts_result = nt3d._extrude_guts(path, shape, shapenormals, pathnormals);
 		// Stitch the ends together
 		return guts_result.points.concat(
 			nt3d.closed_quadstrip(nt3d.zip(guts_result.first_loop, guts_result.last_loop)));
 	},
-	_fix_pathnormals: function(shapenormals, pathnormals) {
-		// Fix pathnormals[i] to be perfectly perpendicular to
-		// shapenormals[i].  This lets extrude callers be sloppy
-		// with pathnormals, which can greatly simplify things.
-		var fixedpathnormals = [];
-		for (var i = 0; i < pathnormals.length; i++) {
-			var proj = this.project(shapenormals[i], pathnormals[i]);
-			fixedpathnormals[i] = this.sub(pathnormals[i], proj);
-		}
-		return fixedpathnormals;
-	},
-	_extrude_guts: function(shape, path, shapenormals, pathnormals) {
-		var fixedpathnormals = this._fix_pathnormals(shapenormals, pathnormals);
+	_extrude_guts: function(path, shape, shapenormals, pathnormals) {
+		var shape_fun = this.to_function(shape, false);
+		var shapenormal_fun = this.to_function(shapenormals, true);
+		var pathnormal_fun = this.to_function(pathnormals, true);
 		var result = { points: [] };
 		var prev_loop;
 		for (var i = 0; i < path.length; i++) {
-			// loop is shape in 3d with (0,0) at path[i], shape's
-			// z axis in the direction of shapenormals[i], and
-			// shape's x axis in the direction of pathnormals[i].
-			// We tack [1,0,0] onto the end as a hack to see where
-			// it ends up after rotation.  This is removed later.
-			var loop = shape.concat([[1,0,0]]);
+			var shapenormali = shapenormal_fun(i, path[i]);
+			var pathnormali = pathnormal_fun(i, path[i], shapenormali);
+
+			// Fix pathnormali to be perfectly perpendicular to
+			// shapenormali.  pathnormali must be perpendicular to
+			// shapenormali or the second rotation will take loop
+			// back out of the shapenormali plane that the first
+			// rotation so carefully placed it in.  But, letting
+			// callers be sloppy with the pathnormals can greatly
+			// simplify generating them -- so much so that you can
+			// often just pass a constant to use the same value
+			// along the whole path.
+			pathnormali = this.project_to_orthogonal(shapenormali, pathnormali);
+
+			var shapei = shape_fun(i, path[i], shapenormali, pathnormali);
+
+			// loop is shapei in 3d with (0,0) at path[i], shape's
+			// z axis in the direction of shapenormali, and shape's
+			// x axis in the direction of pathnormali.  We tack
+			// [1,0,0] onto the end as a hack to see where it ends
+			// up after the first rotation.  This is removed later.
+			var loop = shapei.concat([[1,0,0]]);
 
 			// This is done in three steps:
 			// 1. Rotate shape out of the xy plane so that [0,0,1]
-			//    becomes shapenormals[i].  This puts the shape in
+			//    becomes shapenormali.  This puts the shape in
 			//    the correct plane, but does not constrain its
-			//    rotation about shapenormals[i].
-			loop = this.rotate_onto(loop, [0,0,1], shapenormals[i]);
+			//    rotation about shapenormali.
+			loop = this.rotate_onto(loop, [0,0,1], shapenormali);
 			var shapex = loop.pop();
 
-			// 2. Rotate around shapenormals[i] so that [1,0,0]
-			//    becomes fixedpathnormals[i].
-			loop = this.rotate_onto(loop, shapex, fixedpathnormals[i]);
+			// 2. Rotate around shapenormali so that [1,0,0]
+			//    becomes pathnormali.
+			loop = this.rotate_onto(loop, shapex, pathnormali);
 
 			// (This would probably be faster and more numerically stable
 			// if the two rotations were applied as one combined operation
@@ -171,6 +192,10 @@ nt3d = {
 		var a_magnitude = this.magnitude(a);
 		return this.scale(a, this.dot(a, b) / a_magnitude * a_magnitude);
 	},
+	project_to_orthogonal: function(a, b) {
+		// The nearest thing to b that is orthogonal to a
+		return this.sub(b, this.project(a, b));
+	},
 	translate: function(points, offset) {
 		var translated = [];
 		for (var i = 0; i < points.length; i++) {