fml 0.2.1

data/lib/geom/connection.rb

@@ -0,0 +1,14 @@
+module Geom
+  class Connection
+    alias_method(:==, :equal?)
+    attr_accessor(:point,:angle)
+    def initialize(point,angle)
+      @point = point
+      @angle = angle
+    end
+
+    def equal?(other)
+      other.point == @point && other.angle == @angle
+    end
+  end
+end

data/lib/geom/ear_trim.rb

@@ -0,0 +1,52 @@
+#
+# Implements "Ear trimming" triangulation algorithm
+#
+module Geom
+  class EarTrim
+    def self.triangulate(poly)
+      result  = Array.new
+      points  = poly.vertices.dup
+      num     = points.length
+      count   = num*2
+      indices = Hash.new
+
+      return [ [0,1,2] ] if num == 3
+      points.reverse! if poly.winding == Polygon::WINDING_CW
+      points.each_with_index do |p,i|
+        indices[p] = i
+      end
+
+      while num > 2
+        return nil if count > num*2 # overflow
+        count += 1
+
+        i = 0
+        while i < num
+          j = (i+num-1) % num
+          k = (i+1) % num
+
+          if is_ear(points,j,i,k)
+            # save triangle
+            result.push([indices[points[j]],indices[points[i]],indices[points[k]]])
+            # remove vertex
+            points.delete_at(i)
+            num = points.length
+            count = 0
+          end
+          i += 1
+        end
+      end
+      result
+    end
+
+    def self.is_ear(points,u,v,w)
+      poly = Polygon.new([points[u],points[v],points[w]])
+      return false if poly.area < 0
+      points.length.times do |i|
+        next if i == u || i == v || i == w
+        return false if poly.point_inside(points[i])
+      end
+      true
+    end
+  end
+end

data/lib/geom/edge.rb

@@ -0,0 +1,89 @@
+module Geom
+  class Edge
+    attr_accessor(:start_point,:end_point)
+    def initialize(sp,ep)
+      @start_point = sp
+      @end_point = ep
+    end
+
+    def direction
+      Number3D.sub(@start_point.position,@end_point.position)
+    end
+
+    def length
+      x = @end_point.x - @start_point.x;
+      y = @end_point.y - @start_point.y;
+      z = @end_point.z - @start_point.z;
+      Math.sqrt(x*x + y*y + z*z);
+    end
+
+    def offset(distance,up)
+      up.normalize
+      edge = clone
+      dir  = direction
+
+      Matrix3D.multiply_vector_3x3(Matrix3D.rotation_matrix(up.x,up.y,up.z, -Math::PI/2),dir)
+      dir.normalize
+
+      dir.x *= distance
+      dir.y *= distance
+      dir.z *= distance
+
+      edge.start_point.x += dir.x
+      edge.start_point.y += dir.y
+      edge.start_point.z += dir.z
+      edge.end_point.x += dir.x
+      edge.end_point.y += dir.y
+      edge.end_point.z += dir.z
+
+      edge
+    end
+
+    def extrude(distance,direction)
+      edge = clone
+      [edge.start_point,edge.end_point].each do |v|
+        v.x += distance*direction.x
+        v.y += distance*direction.y
+        v.z += distance*direction.z
+      end
+
+      poly = Polygon.new
+      poly.vertices.push(
+        edge.end_point , edge.start_point,
+        @start_point   , @end_point)
+      poly
+    end
+
+    def snap(point)
+      x1 = @start_point.x
+      y1 = @start_point.y
+      z1 = @start_point.z
+      x2 = @end_point.x
+      y2 = @end_point.y
+      z2 = @end_point.z
+      x3 = point.x
+      y3 = point.y
+      z3 = point.z
+      dx = x2-x1
+      dy = y2-y1
+      dz = z2-z1
+      if dx == 0 && dy == 0 && dz == 0
+        return @start_point
+      else
+        t = ((x3 - x1) * dx + (y3 - y1) * dy + (z3 - z1) * dz) / (dx**2 + dy**2 + dz**2)
+        x0 = x1 + t * dx
+        y0 = y1 + t * dy
+        z0 = z1 + t * dz
+        return Vertex.new(x0,y0,z0)
+      end
+    end
+
+    def clone
+      Edge.new(@start_point.clone,@end_point.clone)
+    end
+
+    def to_s
+      "#<Geom::Edge:#{@start_point.to_s},#{@end_point.to_s}>"
+    end
+  end
+end

data/lib/geom/glu_tess.rb

@@ -0,0 +1,34 @@
+require 'opengl'
+
+module Geom
+  class GluTesselator
+    include Gl,Glu,Glut
+    def self.triangulate(poly)
+      result = Array.new
+
+      t = gluNewTess
+      gluTessCallback(t,GLU_TESS_VERTEX,method(:vertex_callback).to_proc)
+      gluTessCallback(t,GLU_TESS_BEGIN,method(:begin_callback).to_proc)
+      gluTessCallback(t,GLU_TESS_EDGE_FLAG,proc{})
+      gluTessBeginPolygon(t,self)
+      gluTessBeginContour(t)
+
+      poly.vertices.each_with_index do |v,i|
+        gluTessVertex(t,[v.x,v.y,v.z],v)
+      end
+
+      gluTessEndContour(t)
+      gluTessEndPolygon(t)
+    end
+
+    private
+
+    def self.vertex_callback(v)
+      puts v
+    end
+
+    def self.begin_callback(a)
+      puts "begin"
+    end
+  end
+end

data/lib/geom/intersection.rb

@@ -0,0 +1,38 @@
+module Geom
+  class Intersection
+    INTERSECTION    = 1
+    NO_INTERSECTION = 0
+    attr_accessor(:alpha,:points,:status)
+    def initialize(status=NO_INTERSECTION)
+      @alpha  = Array.new
+      @points = Array.new
+      @status = status
+    end
+
+    def self.line_line(a1,a2,b1,b2,infinite=true)
+      result = Intersection.new
+
+      x1, y1 = a1.x, a1.y
+      x2, y2 = a2.x, a2.y
+      x3, y3 = b1.x, b1.y
+      x4, y4 = b2.x, b2.y
+
+      d = ((y4-y3)*(x2-x1)-(x4-x3)*(y2-y1))
+
+      unless d.zero?
+        # The lines intersect at a point somewhere
+        ua = ((x4-x3)*(y1-y3)-(y4-y3)*(x1-x3)) / d
+        ub = ((x2-x1)*(y1-y3)-(y2-y1)*(x1-x3)) / d
+
+        result.alpha.push(ua,ub)
+        if infinite || ((ua > 0 && ua < 1) && (ub > 0 && ub < 1))
+          x = x1 + ua*(x2-x1)
+          y = y1 + ua*(y2-y1)
+          result.points << Number3D.new(x,y)
+          result.status = INTERSECTION;
+        end
+      end
+      result
+    end
+  end
+end

data/lib/geom/matrix3d.rb

@@ -0,0 +1,141 @@
+module Geom
+  class Matrix3D < Matrix
+    def self.identity
+      Matrix3D[
+        [1,0,0,0],
+        [0,1,0,0],
+        [0,0,1,0],
+        [0,0,0,1]
+      ]
+    end
+
+    def self.rotation_matrix(x,y,z,rad)
+      n_cos = Math.cos(rad)
+      n_sin = Math.sin(rad)
+      s_cos = 1 - n_cos
+
+      sxy = x * y * s_cos
+      syz = y * z * s_cos
+      sxz = x * z * s_cos
+
+      sz  = n_sin * z
+      sy  = n_sin * y
+      sx  = n_sin * x
+
+      n11  = n_cos + x * x * s_cos
+      n12  = -sz + sxy
+      n13  = sy + sxz
+      n14  = 0
+
+      n21  = sz + sxy
+      n22  = n_cos + y * y * s_cos
+      n23  = -sx + syz
+      n24  = 0
+
+      n31  = -sy + sxz
+      n32  = sx + syz
+      n33  = n_cos + z * z * s_cos
+      n34  = 0
+
+      self[
+        [n11,n12,n13,n14],
+        [n21,n22,n23,n24],
+        [n31,n32,n33,n34],
+        [0,0,0,1]
+      ]
+    end
+
+    def self.rotationX(rad)
+      c = Math.cos(rad)
+      s = Math.sin(rad)
+
+      self[
+        [1,0, 0,0],
+        [0,c,-s,0],
+        [0,s, c,0],
+        [0,0, 0,1],
+      ]
+    end
+
+    def self.rotationZ(rad)
+      c  = Math.cos(rad)
+      s  = Math.sin(rad)
+
+      self[
+        [c,-s,0,0],
+        [s, c,0,0],
+        [0, 0,1,0],
+        [0, 0,0,1]
+      ]
+    end
+
+    def self.translation(x,y,z)
+      self[
+        [1,0,0,x],
+        [0,1,0,y],
+        [0,0,1,z],
+        [0,0,0,1]
+      ]
+    end
+
+    def self.scale(x,y,z)
+      self[
+        [x,0,0,0],
+        [0,y,0,0],
+        [0,0,z,0],
+        [0,0,0,1]
+      ]
+    end
+
+    def self.reflection(plane)
+      a = plane.normal.x
+      b = plane.normal.y
+      c = plane.normal.z
+
+      self[
+        [1-(2*a*a) , 0-(2*a*b) , 0-(2*a*c) , 0],
+        [0-(2*a*b) , 1-(2*b*b) , 0-(2*b*c) , 0],
+        [0-(2*a*c) , 0-(2*b*c) , 1-(2*c*c) , 0],
+        [0         , 0         , 0         , 1]
+      ]
+    end
+
+    def self.multiply_vector_3x3(m,v)
+      ma = m.to_a
+      vx = v.x
+      vy = v.y
+      vz = v.z
+
+      v.x = vx * ma[0][0] + vy * ma[0][1] + vz * ma[0][2]
+      v.y = vx * ma[1][0] + vy * ma[1][1] + vz * ma[1][2]
+      v.z = vx * ma[2][0] + vy * ma[2][1] + vz * ma[2][2]
+    end
+
+    def multiply(other)
+      # matrix multiplication is m[r][c] = (row[r]).(col[c])
+      s = to_a
+      o = other.to_a
+      rm00 = s[0][0] * o[0][0] + s[0][1] * o[1][0] + s[0][2] * o[2][0]
+      rm01 = s[0][0] * o[0][1] + s[0][1] * o[1][1] + s[0][2] * o[2][1]
+      rm02 = s[0][0] * o[0][2] + s[0][1] * o[1][2] + s[0][2] * o[2][2]
+      rm03 = s[0][0] * o[0][3] + s[0][1] * o[1][3] + s[0][2] * o[2][3] + s[0][3]
+
+      rm10 = s[1][0] * o[0][0] + s[1][1] * o[1][0] + s[1][2] * o[2][0]
+      rm11 = s[1][0] * o[0][1] + s[1][1] * o[1][1] + s[1][2] * o[2][1]
+      rm12 = s[1][0] * o[0][2] + s[1][1] * o[1][2] + s[1][2] * o[2][2]
+      rm13 = s[1][0] * o[0][3] + s[1][1] * o[1][3] + s[1][2] * o[2][3] + s[1][3]
+
+      rm20 = s[2][0] * o[0][0] + s[2][1] * o[1][0] + s[2][2] * o[2][0]
+      rm21 = s[2][0] * o[0][1] + s[2][1] * o[1][1] + s[2][2] * o[2][1]
+      rm22 = s[2][0] * o[0][2] + s[2][1] * o[1][2] + s[2][2] * o[2][2]
+      rm23 = s[2][0] * o[0][3] + s[2][1] * o[1][3] + s[2][2] * o[2][3] + s[2][3]
+
+      Matrix3D[
+        [rm00, rm01, rm02, rm03],
+        [rm10, rm11, rm12, rm13],
+        [rm20, rm21, rm22, rm23]
+      ]
+    end
+
+  end
+end

data/lib/geom/number.rb

@@ -0,0 +1,104 @@
+module Geom
+
+  class Number3D
+
+    attr_accessor(:x,:y,:z)
+
+    def initialize(x=0,y=0,z=0)
+      @x, @y, @z = x, y, z
+    end
+
+    def self.sub(v,w)
+      Number3D.new(
+        v.x - w.x,
+        v.y - w.y,
+        v.z - w.z
+      )
+    end
+
+    def self.cross(v,w,target=nil)
+      target ||= Number3D.new
+      target.reset((w.y * v.z) - (w.z * v.y), (w.z * v.x) - (w.x * v.z), (w.x * v.y) - (w.y * v.x))
+      target
+    end
+
+    def self.dot(v,w)
+      v.x * w.x + v.y * w.y + w.z * v.z
+    end
+
+    def self.from_str(str)
+      x,y,z = str.split(' ') if str
+      str.nil? ? Number3D.new : Number3D.new(x.to_f,y.to_f,z.to_f)
+    end
+
+    def reset(nx=nil,ny=nil,nz=nil)
+      @x = nx if nx
+      @y = ny if ny
+      @z = nz if nz
+    end
+
+    def normalize
+      mod = Math.sqrt( @x**2 + @y**2 + @z**2 )
+      if mod != 0 && mod != 1
+        mod = 1 / mod # mults are cheaper then divs
+        @x *= mod
+        @y *= mod
+        @z *= mod
+      end
+    end
+
+    def minus_eq(v)
+      @x -= v.x
+      @y -= v.y
+      @z -= v.z
+    end
+
+    def distance_x(other)
+      (@x - other.x).abs
+    end
+
+    def distance_y(other)
+      (@y - other.y).abs
+    end
+
+    def distance_z(other)
+      (@z - other.z).abs
+    end
+
+    def distance(other)
+      Math.sqrt(
+        distance_z(other) ** 2 +
+        Math.sqrt(distance_x(other)**2 + distance_y(other)**2) ** 2
+      )
+    end
+
+    def == (other)
+      @x == other.x &&
+      @y == other.y &&
+      @z == other.z
+    end
+
+    def to_s
+      "#<Geom::Number3D:#{@x},#{@y},#{@z}>"
+    end
+
+    def to_floats
+      [@x,@y,@z].join ' '
+    end
+  end
+
+  class NumberUV
+
+    attr_accessor :u, :v
+
+    def initialize(u=0,v=0)
+      @u = u
+      @v = v
+    end
+
+    def clone
+      NumberUV.new(u,v)
+    end
+  end
+
+end

data/lib/geom/plane.rb

@@ -0,0 +1,36 @@
+module Geom
+  class Plane
+    attr_accessor(:normal)
+    def initialize(normal=nil,point=nil)
+      if normal && point
+        @normal = normal
+        @d      = -Number3D.dot(normal,point)
+      else
+        @normal = Number3D.new
+        @d      = 0
+      end
+    end
+
+    def self.three_points(p0,p1,p2)
+      plane = Plane.new
+      n0 = p0.instance_of?(Number3D) ? p0 : p0.position
+      n1 = p1.instance_of?(Number3D) ? p1 : p1.position
+      n2 = p2.instance_of?(Number3D) ? p2 : p2.position
+      plane.set_three_points(n0,n1,n2)
+      plane
+    end
+
+    def set_three_points(p0,p1,p2)
+      ab = Number3D.sub(p1,p0)
+      ac = Number3D.sub(p2,p0)
+      @normal = Number3D.cross(ab,ac)
+      @normal.normalize
+      @d = -Number3D.dot(@normal,p0)
+    end
+
+    def distance(point)
+      p = point.instance_of?(Vertex) ? point.position : point
+      Number3D.dot(p,@normal) + @d
+    end
+  end
+end