Make extrude's arguments more flexible and powerful

[nt3d] / nt3d.js

diff --git a/nt3d.js b/nt3d.js
index 7472548fddfb800f2df62055983b90dda57a3878..9b09b09532e233aa5b450130bd36d4bd43be02e2 100644 (file)
--- a/nt3d.js
+++ b/nt3d.js
@@ -55,8 +55,29 @@ nt3d = {
                }
                return points;
        },
                }
                return points;
        },

-       extrude: function(shape, path, shapenormals, pathnormals) {
-               var guts_result = nt3d._extrude_guts(shape, path, shapenormals, pathnormals);
+       cone: function(base_center, apex, radius, steps) {
+               var base = this.circle(radius, steps);
+               base = this.rotate_onto(base, [0,0,1], this.sub(apex, base_center));
+               base = this.translate(base, base_center);
+               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);

                // Add the end-caps
                // XXX: This doesn't work if shape is not convex
                return guts_result.points.concat(
                // Add the end-caps
                // XXX: This doesn't work if shape is not convex
                return guts_result.points.concat(


@@ -64,46 +85,53 @@ nt3d = {
                        nt3d.trianglefan(guts_result.last_loop));
 
        },
                        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)));
        },
                // 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++) {
                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]
 
                        // 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
                        //    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();
 
                        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
 
                        // (This would probably be faster and more numerically stable
                        // if the two rotations were applied as one combined operation


@@ -164,6 +192,10 @@ nt3d = {
                var a_magnitude = this.magnitude(a);
                return this.scale(a, this.dot(a, b) / a_magnitude * a_magnitude);
        },
                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++) {
        translate: function(points, offset) {
                var translated = [];
                for (var i = 0; i < points.length; i++) {