Make extrude's arguments more flexible and powerful

diff --git a/box_by_extrude.html b/box_by_extrude.html
index be95de64ade3309ee6f56697df71f964afbfb73b..fb1ca2cf61592cfa8ec72896ec9ddae36bc53880 100644 (file)
--- 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 a4d3977f9815714252a98370d441b2ed2b467bcf..9b09b09532e233aa5b450130bd36d4bd43be02e2 100644 (file)
--- 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 69bbdabc4a9150970d655cb41448dc1404a5686d..c95f8216532e4ac27bff2c4ed48bbd2cb7aa0772 100644 (file)
--- 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],