jax 1.1.1 → 2.0.0

data/lib/assets/javascripts/jax/geometry/plane.js

@@ -0,0 +1,371 @@
+/**
+ * class Jax.Geometry.Plane
+ *
+ * Represents a plane in 3 dimensions.
+ *
+ * Examples:
+ *
+ *     new Jax.Geometry.Plane([0,0,0], [0,1,0], [1,0,0]);
+ *     new Jax.Geometry.Plane([[0,0,0], [0,1,0], [1,0,0]]);
+ *     new Jax.Geometry.Plane();
+ *
+ **/
+Jax.Geometry.Plane = (function() {
+  var bufs = {};
+  
+  function innerProduct(a, x, y, z) {
+    return (a[0]*x + a[1]*y + a[2]*z);
+  }
+
+  var Plane = Jax.Class.create({
+    toString: function() {
+      return "[Plane normal:"+this.normal+"; D:"+this.d+"]";
+    },
+    
+    /**
+     * Jax.Geometry.Plane#intersectTriangle(t[, line]) -> Boolean
+     * - t (Jax.Geometry.Triangle): a triangle
+     * - line (Jax.Geometry.Line): optional Line to store the line of intersection
+     *
+     * Tests the triangle for intersection with this plane. If an intersection is found,
+     * it may be stored in +line+. If +line+ is omitted, this data is ignored.
+     *
+     * Returns the result of the test: true for intersection, false otherwise.
+     **/
+    intersectTriangle: function(t, line) {
+      var ad = this.classify(t.a), bd = this.classify(t.b), cd = this.classify(t.c);
+      var sideAB = ad * bd, sideBC = bd * cd;
+      if (sideAB > 0.0 && sideBC > 0.0) return false; // all points on same side of plane
+      
+      // at this point we know there is an intersection. If +line+ is undefined, we can stop.
+      if (!line) return true;
+      
+      // find which point is on opposite side of plane, and which 2 lie on same side
+      var otherSide, sameSide1, sameSide2;
+      if (sideAB > 0) {
+        sameSide1 = t.a;
+        sameSide2 = t.b;
+        otherSide = t.c;
+      } else {
+        if (sideBC > 0) {
+          otherSide = t.a;
+          sameSide1 = t.b;
+          sameSide2 = t.c;
+        } else {
+          sameSide1 = t.a;
+          otherSide = t.b;
+          sameSide2 = t.c;
+        }
+      }
+      
+      var seg1 = bufs.tri_seg1 = bufs.tri_seg1 || new Jax.Geometry.Line();
+      var seg2 = bufs.tri_seg2 = bufs.tri_seg2 || new Jax.Geometry.Line();
+      seg1.set(otherSide, sameSide1);
+      seg2.set(otherSide, sameSide2);
+      
+      // the result is simply the line from the intersection point of seg1 to the isect of seg2
+      var p1 = bufs.tri_p1 = bufs.tri_p1 || vec3.create(),
+          p2 = bufs.tri_p2 = bufs.tri_p2 || vec3.create();
+      this.intersectLineSegment(seg1, p1);
+      this.intersectLineSegment(seg2, p2);
+      return line.set(p1, p2);
+    },
+    
+    /**
+     * Jax.Geometry.Plane#intersectLineSegment(line[, point]) -> Number
+     * - line (Jax.Geometry.Line): a Line to test against
+     * - point (vec3): an optional receiving vec3 to store the point of intersection in
+     *
+     * Returns Jax.Geometry.DISJOINT (which equals 0) if no intersection occurs,
+     * Jax.Geometry.COINCIDE if the line segment is contained on this plane,
+     * or Jax.Geometry.INTERSECT if the line segment intersects this plane.
+     *
+     * In the last case, if +point+ is given, the exact point of intersection will be
+     * stored. Otherwise, this data is ignored.
+     **/
+    intersectLineSegment: function(line, point) {
+      var u = vec3.subtract(line.b, line.a, (bufs.lineseg_u = bufs.lineseg_u || vec3.create()));
+      var w = vec3.subtract(line.a, this.point, (bufs.lineseg_w = bufs.lineseg_w || vec3.create()));
+      var D =  vec3.dot(this.normal, u);
+      var N = -vec3.dot(this.normal, w);
+      
+      if (Math.abs(D) < Math.EPSILON)             // segment is parallel to plane
+        if (N == 0) return Jax.Geometry.COINCIDE; // segment lies in plane
+        else return Jax.Geometry.DISJOINT;
+      
+      // they are not parallel
+      var sI = N / D;
+      if (sI < 0 || sI > 1)
+        return Jax.Geometry.DISJOINT;
+      
+      if (point)
+        vec3.add(line.a, vec3.scale(u, sI, point), point);
+      
+      return Jax.Geometry.INTERSECT;
+    },
+    
+    /**
+     * Jax.Geometry.Plane#intersectRay(origin, direction) -> Number | false
+     * - origin (vec3): the point at which the ray begins
+     * - direction (vec3): the direction the ray extends. This must be
+     *                     a unit vector.
+     *
+     * Returns the distance along the ray at which an intersection with this
+     * plane occurs. If the ray is parallel to this plane, returns false.
+     * If the ray is pointing away from this plane, a negative number will
+     * be returned.
+     *
+     * The +direction+ argument must be normalized for the result to be accurate.
+     **/
+    intersectRay: function(origin, direction) {
+      var numer = vec3.dot(this.normal, origin) + this.d;
+      var denom = vec3.dot(this.normal, direction);
+      
+      if (denom == 0) // normal is orthogonal to vector, can't intersect
+        return false;
+        
+      var result = -(numer / denom);
+      return -(numer / denom);
+    },
+    
+    /**
+     * Jax.Geometry.Plane#intersectPlane(p[, line]) -> Number
+     * - p (Jax.Geometry.Plane): the plane to test for intersection
+     * - line (Jax.Geometry.Line): an optional receiving Line to contain the intersection
+     *
+     * Tests this plane against the +p+ for intersection. If no intersection is found,
+     * the value Jax.Geometry.DISJOINT (which equals 0) is returned.
+     *
+     * If the planes are the same, the value Jax.Geometry.COINCIDE is returned.
+     *
+     * Otherwise, the value Jax.Geometry.INTERSECT is returned. If +line+ was given,
+     * the exact line of intersection will be stored within it. Otherwise, this data
+     * is ignored.
+     **/
+    intersectPlane: function(p, line) {
+      var d1 = this.d, d2 = p.d;
+      var p1n = this.normal, p2n = p.normal;
+      var u = bufs.u = bufs.u || vec3.create();
+      vec3.cross(p1n, p2n, u);
+      var ax = (u[0] >= 0 ? u[0] : -u[0]);
+      var ay = (u[1] >= 0 ? u[1] : -u[1]);
+      var az = (u[2] >= 0 ? u[2] : -u[2]);
+      
+      // test if the two planes are parallel
+      if ((ax+ay+az) < Math.EPSILON) { // planes are near parallel
+        // test if disjoint or coincide
+        if (Math.equalish(d1, d2)) return Jax.Geometry.COINCIDE;
+        else return Jax.Geometry.DISJOINT;
+      }
+      
+      if (line) {
+        // both planes intersect a line
+        // first determine max abs coordinate of cross product
+        var maxc;
+        if (ax > ay)
+          if (ax > az) maxc = 0;
+          else maxc = 2;
+        else
+          if (ay > az) maxc = 1;
+          else maxc = 2;
+        
+        // next, to get a point on the intersect line
+        // zero the max coord, and solve for the other two
+        var iP = bufs.iP = bufs.iP || vec3.create(); // intersection point
+        switch(maxc) {
+          case 0: // intersect with x = 0
+            iP[0] = 0;
+            iP[1] = (d2 * p1n[2] - d1 * p2n[2]) / u[0];
+            iP[2] = (d1 * p2n[1] - d2 * p1n[1]) / u[0];
+            break;
+          case 1: // intersect with y = 0
+            iP[0] = (d1 * p2n[2] - d2 * p1n[2]) / u[1];
+            iP[1] = 0;
+            iP[2] = (d2 * p1n[0] - d1 * p2n[0]) / u[1];
+            break;
+          case 2: // intersect with z = 0
+            iP[0] = (d2 * p1n[1] - d1 * p2n[1]) / u[2];
+            iP[1] = (d1 * p2n[0] - d2 * p1n[0]) / u[2];
+            iP[2] = 0;
+            break;
+        }
+        
+        vec3.set(iP,    line[0]);
+        vec3.add(iP, u, line[1]);
+      }
+      
+      return Jax.Geometry.INTERSECT;
+    },
+    
+    /**
+     * new Jax.Geometry.Plane(v1, v2, v3)
+     * new Jax.Geometry.Plane(position, normal)
+     * new Jax.Geometry.Plane(array_of_vertices)
+     * new Jax.Geometry.Plane()
+     * - v1 (vec3): first vertex
+     * - v2 (vec3): second vertex
+     * - v3 (vec3): third vertex
+     * - array_of_vertices (Array): array of vertices in the form +[[x,y,z], [x,y,z], [x,y,z]]+
+     * - position (vec3): the position of a point known to be in the plane
+     * - normal (vec3): the vector normal to the surface of the plane
+     *
+     * If initialized with no arguments, the result is undefined until
+     * the +set+ method is called. See +Jax.Geometry.Plane#set+
+     **/
+    initialize: function(points) {
+      /**
+       * Jax.Geometry.Plane#point -> vec3
+       *
+       * A point in world space known to coincide with this plane.
+       *
+       * You can construct a duplicate of this plane with the following code:
+       *
+       *     var copy = new Plane(plane.point, plane.normal);
+       *
+       **/
+      this.point = vec3.create();
+      
+      /**
+       * Jax.Geometry.Plane#normal -> vec3
+       *
+       * The normal pointing perpendicular to this plane, assuming the front face is produced
+       * by winding the vertices counter-clockwise.
+       *
+       * If the plane is constructed with no arguments, the normal defaults to the world up
+       * direction [0,1,0].
+       **/
+      this.normal = vec3.create([0,1,0]);
+      
+      /**
+       * Jax.Geometry.Plane#d -> Number
+       *
+       * The fourth component in the plane equation.
+       **/
+      this.d = 0.0;
+      
+      if (arguments.length)
+        this.set.apply(this, arguments);
+    },
+    
+    /**
+     * Jax.Geometry.Plane#classify(O) -> Number
+     * - O (vec3): origin
+     * 
+     * equivalent to vec3.dot(this.normal, O) + this.d;
+     **/
+    classify: function(O) {
+      if (O.array) return vec3.dot(this.normal, O.array) + this.d;
+      else return vec3.dot(this.normal, O) + this.d;
+    },
+    
+    /**
+     * Jax.Geometry.Plane#set(points) -> Jax.Geometry.Plane
+     * Jax.Geometry.Plane#set(point0, point1, point2) -> Jax.Geometry.Plane
+     * Jax.Geometry.Plane#set(position, normal) -> Jax.Geometry.Plane
+     * - points (Array): an array of 3 vectors.
+     * - point0 (vec3): the first of 3 vectors.
+     * - point1 (vec3): the second of 3 vectors.
+     * - point2 (vec3): the third of 3 vectors.
+     * - position (vec3): the position of a point known to be in the plane
+     * - normal (vec3): the vector normal to the surface of the plane
+     * 
+     * Sets this plane's coefficients based off of either a set of three 3D points,
+     * or a single known point on the plane and the plane's normal.
+     *
+     * This plane is returned.
+     **/
+    set: function() {
+      if (arguments.length == 2) {
+        vec3.set(arguments[1], this.normal);
+        this.d = -vec3.dot(arguments[1], arguments[0]);
+      } else {
+        var tmp1 = this.normal, tmp2 = vec3.create();
+        var points = arguments;
+        
+        if (arguments.length != 3) points = arguments[0];
+        if (typeof(points[0]) == 'object' && points[0].array) {
+          vec3.subtract(points[1].array, points[0].array, tmp1);
+          vec3.subtract(points[2].array, points[0].array, tmp2);
+          vec3.normalize(vec3.cross(tmp1, tmp2, this.normal));
+          this.d = -vec3.dot(this.normal, points[0].array);
+        } else {
+          vec3.subtract(points[1], points[0], tmp1);
+          vec3.subtract(points[2], points[0], tmp2);
+          vec3.normalize(vec3.cross(tmp1, tmp2, this.normal));
+          this.d = -vec3.dot(this.normal, points[0]);
+        }
+      }
+      
+      vec3.scale(this.normal, this.d, this.point);
+      return this;
+    },
+    
+    /**
+     * Jax.Geometry.Plane#setCoefficients(a, b, c, d) -> Jax.Geometry.Plane
+     *
+     * Sets the four coefficients A, B, C, D for this plane.
+     *
+     * Returns this plane.
+     **/
+    setCoefficients: function(a, b, c, d) {
+      var len = Math.sqrt(a*a+b*b+c*c);
+      this.normal[0] = a/len;
+      this.normal[1] = b/len;
+      this.normal[2] = c/len;
+      this.d = d/len;
+      return this;
+    },
+    
+    /**
+     * Jax.Geometry.Plane#distance(point) -> Number
+     * - point (vec3): A 3D vector. Can be any type with values for indices [0..2] (e.g. an Array).
+     *
+     * Given a 3D point, returns the distance from this plane to the point. The point is expected
+     * to lie in the same 3D space as this plane.
+     **/
+     // replaced with alias of #classify
+    // distance: function(point)
+    // {
+    //   // same as ax + by + cz + d
+    //   return this.classify(point);
+    // },
+    
+    /**
+     * Jax.Geometry.Plane#whereis(point) -> Number
+     * - point (vec3): A 3D vector. Can be any type with values for indices [0..2] (e.g. an Array).
+     *
+     * Given a point in 3D space, returns one of the following values based on the position
+     * of the point relative to this plane:
+     *
+     *     Jax.Geometry.Plane.FRONT
+     *     Jax.Geometry.Plane.BACK
+     *     Jax.Geometry.Plane.INTERSECT
+     *
+     * FRONT represents a point lying somewhere in the direction of the plane's normal.
+     * BACK represents the opposite, and INTERSECT represents a point lying directly
+     * parallel to this plane.
+     *
+     * The point is expected to lie in the same 3D space as this plane.
+     **/
+    whereis: function()
+    {
+      var point;
+      if (arguments.length == 3) point = arguments;
+      else if (arguments[0].array) point = arguments[0].array;
+      else point = arguments[0];
+      
+      var d = this.distance(point);
+      if (d > 0) return Jax.Geometry.Plane.FRONT;
+      if (d < 0) return Jax.Geometry.Plane.BACK;
+      return Jax.Geometry.Plane.INTERSECT;
+    }
+  });
+  
+  Plane.prototype.distance = Plane.prototype.classify;
+  
+  return Plane;
+})();
+
+Jax.Geometry.Plane.FRONT     = 1;
+Jax.Geometry.Plane.BACK      = 2;
+Jax.Geometry.Plane.INTERSECT = 3;

data/lib/assets/javascripts/jax/geometry/triangle/inliner.rb

@@ -0,0 +1,94 @@
+src = File.read("tri_tri_intersect.js")
+
+# build list of inline functions
+inlines = []
+signature_rx = /function\s*\/\*\s*inline\s*\*\/\s*([a-zA-Z0-9_$]+)\s*\((.*?)\)\s*\{/m
+
+while src =~ signature_rx
+  function_definition_offset = $~.offset(0)[0]
+  function_body_offset_start = $~.offset(0)[1]
+  function_body_offset_end = function_body_offset_start
+  function_name = $1
+  params_list = $2.split(/,/)
+  puts "Inline: #{function_name}(#{params_list}) (beginning at offset #{function_body_offset_start})"
+  
+  scope_depth = 1
+  for i in function_body_offset_start...src.length
+    case src[i]
+      when ?{
+        scope_depth += 1
+      when ?}
+        scope_depth -= 1
+        if scope_depth == 0 # function body end
+          function_body_offset_end = i
+          break
+        end
+    end
+  end
+  if scope_depth > 0
+    raise "Couldn't find a closing curly brace for inline function #{function_name}!"
+  end
+  
+  function_body = src[function_body_offset_start...function_body_offset_end]
+  
+  src = (src[0...function_definition_offset].to_s + src[(function_body_offset_end+1)..-1].to_s).strip
+
+  # last step: make sure param names are unique to this function
+  params_list.collect! do |name|
+    new_name = "#{function_name}_#{name}"
+    # function_body.gsub! /#{Regexp::escape name}/, new_name
+    function_body.gsub! /([^a-zA-Z0-9_$])#{Regexp::escape name}([^a-zA-Z0-9_$])/, "\\1#{new_name}\\2"
+    new_name
+  end
+
+  inlines << { :name => function_name, :params => params_list, :body => function_body }
+end
+
+# parse src and replace funcalls to inline functions
+again = true
+while again
+  again = false
+  inlines.each do |inline|
+    if src =~ /#{inline[:name]}\s*\(/
+      function_call_start = $~.offset(0)[0]
+      function_params_start = $~.offset(0)[1]
+      function_params_end = function_params_start
+      parens_depth = 1
+      for i in function_params_start...src.length
+        case src[i]
+        when ?(
+          parens_depth += 1
+        when ?)
+          parens_depth -= 1
+          if parens_depth == 0 # params end
+            # see if there's (optionally, white space, followed by) a semicolon
+            # if there is, it's superfluous; get rid of it.
+            if src[(i+1)..-1] =~ /\A([\s\n\t]*;)/m
+              src[(i+1)..(i+$1.length)] = ""
+            end
+            function_params_end = i
+            break
+          end
+        end
+      end
+      params = src[function_params_start...function_params_end].split(/,/)
+      puts "Discovered call to #{inline[:name]} with params: #{params.inspect}"
+    
+      if params.length != inline[:params].length
+        raise "Incorrect params length: #{params.length} for #{inline[:params].length}\n\t\t\t(expected params are: #{inline[:params].inspect})"
+      end
+      inline_body = inline[:body].dup
+      for i in 0...params.length
+        inline_body.gsub! /([^a-zA-Z0-9_$])#{Regexp::escape inline[:params][i]}([^a-zA-Z0-9_$])/, "\\1#{params[i]}\\2"
+      end
+    
+      inline_body = "/* (inline function #{inline[:name]}) */\n#{inline_body}"
+      src[function_call_start..function_params_end] = inline_body
+      again = true
+    end
+  end
+end
+
+dst = File.open("tri_tri_intersect_optimized.js", "w") do |f|
+  f.puts src
+end

data/lib/assets/javascripts/jax/geometry/triangle/slow_tri_tri_intersect.js

@@ -0,0 +1,20 @@
+var bufs;
+if (typeof(bufs) == 'undefined') // in case it was defined elsewhere
+  bufs = {};
+  
+// Although slower than 'tri_tri_intersect', this implementation
+// will find and store the exact point of intersection.
+
+// t1, t2: a triangle
+// dest: a vec3 to contain intersection point
+// If the return value is false, the value of dest will be unknown.
+function slow_tri_tri_intersect(t1, t2, dest)
+{
+  var line1 = bufs.slowtri_line1 = bufs.slowtri_line1 || new Jax.Geometry.Line();
+  var line2 = bufs.slowtri_line2 = bufs.slowtri_line2 || new Jax.Geometry.Line();
+  if (t1.plane.intersectTriangle(t2, line1) && t2.plane.intersectTriangle(t1, line2)) {
+    line1.intersectLineSegment(line2, dest);
+    return true;
+  }
+  else return false;
+}