From: Scott Worley <ScottWorley@ScottWorley.com>
Date: Fri, 21 Dec 2012 06:29:48 +0000 (-0800)
Subject: Make extrude's arguments more flexible and powerful
X-Git-Url: http://git.scottworley.com/nt3d/commitdiff_plain/08c25ec8473e43e82a1291a528f8332239581483

Make extrude's arguments more flexible and powerful
---

diff --git a/box_by_extrude.html b/box_by_extrude.html
index be95de6..fb1ca2c 100644
--- a/box_by_extrude.html
+++ b/box_by_extrude.html
@@ -10,8 +10,8 @@
         var xy     = [size, size, 0];
       	return nt3d.extrude([[0, 0, 0], [0, 0, 1]],
       	                    [origin, x, xy, y],
-      	                    [[0, 0, 1], [0, 0, 1]],
-      	                    [[1, 0, 0], [1, 0, 0]]);
+      	                    [0, 0, 1],
+      	                    [1, 0, 0]);
       }
       var params = [["Size", 1]];
     </script>
diff --git a/nt3d.js b/nt3d.js
index a4d3977..9b09b09 100644
--- a/nt3d.js
+++ b/nt3d.js
@@ -62,6 +62,19 @@ nt3d = {
 		return this.closed_trianglefan([apex].concat(base)).concat(
 		       this.trianglefan(base.reverse()));
 	},
+	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);
@@ -78,40 +91,47 @@ nt3d = {
 		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(path, shape, shapenormals, pathnormals) {
-		var fixedpathnormals = this._fix_pathnormals(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
@@ -172,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++) {
diff --git a/torus_by_extrude.html b/torus_by_extrude.html
index 69bbdab..c95f821 100644
--- a/torus_by_extrude.html
+++ b/torus_by_extrude.html
@@ -5,14 +5,11 @@
     <script type="text/javascript">
       function torus_by_extrude(torus_radius, cross_section_radius, long_steps, short_steps) {
       	var path = nt3d.circle(torus_radius, long_steps);
-      	var cross_section = nt3d.circle(cross_section_radius, short_steps);
-      	var cross_section_normals = nt3d.rotate_about_origin(path, [0,0,1], Math.PI/2);
-      	var path_normals = [];
-      	path_normals.length = long_steps;
-      	for (var i = 0; i < long_steps; i++) {
-      		path_normals[i] = [0, 0, 1];
-      	}
-      	return nt3d.closed_extrude(path, cross_section, cross_section_normals, path_normals);
+      	return nt3d.closed_extrude(
+      	  path,
+	  nt3d.circle(cross_section_radius, short_steps),
+      	  nt3d.rotate_about_origin(path, [0,0,1], Math.PI/2),
+	  [0, 0, 1]);
       }
       var params = [["Torus radus", 100],
                     ["Cross section radius", 40],