mittsu 0.1.0

data/lib/mittsu/math/plane.rb

@@ -0,0 +1,128 @@
+require 'mittsu/math'
+
+module Mittsu
+  class Plane
+    attr_accessor :normal, :constant
+
+    def initialize(normal = Mittsu::Vector3.new(1, 0, 0), constant = 0.0)
+      @normal, @constant = normal, constant.to_f
+    end
+
+    def set(normal, constant)
+      @normal.copy(normal)
+      @constant = constant.to_f
+      self
+    end
+
+    def set_components(x, y, z, w)
+      @normal.set(x, y, z)
+      @constant = w.to_f
+      self
+    end
+
+    def set_from_normal_and_coplanar_point(normal, point)
+      @normal.copy(normal)
+      @constant = -point.dot(@normal) # must be @normal, not normal, as @normal is normalized
+      self
+    end
+
+    def set_from_coplanar_points(a, b, c)
+      v1 = Mittsu::Vector3.new
+      v2 = Mittsu::Vector3.new
+      normal = v1.sub_vectors(c, b).cross(v2.sub_vectors(a, b)).normalize
+      # Q: should an error be thrown if normal is zero (e.g. degenerate plane)?
+      self.set_from_normal_and_coplanar_point(normal, a)
+      self
+    end
+
+    def copy(plane)
+      @normal.copy(plane.normal)
+      @constant = plane.constant
+      self
+    end
+
+    def normalize
+      # Note: will lead to a divide by zero if the plane is invalid.
+      inverse_normal_length = 1.0 / @normal.length
+      @normal.multiply_scalar(inverse_normal_length)
+      @constant *= inverse_normal_length
+      self
+    end
+
+    def negate
+      @constant *= -1.0
+      @normal.negate
+      self
+    end
+
+    def distance_to_point(point)
+      @normal.dot(point) + @constant
+    end
+
+    def distance_to_sphere(sphere)
+      self.distance_to_point(sphere.center) - sphere.radius
+    end
+
+    def project_point(point, target = Mittsu::Vector3.new)
+      self.ortho_point(point, target).sub(point).negate
+    end
+
+    def ortho_point(point, target = Mittsu::Vector3.new)
+      perpendicular_magnitude = self.distance_to_point(point)
+      target.copy(@normal).multiply_scalar(perpendicular_magnitude)
+    end
+
+    def intersection_line?(line)
+      # Note: self tests if a line intersects the plane, not whether it (or its end-points) are coplanar with it.
+      start_sign = self.distance_to_point(line.start_point)
+      end_sign = self.distance_to_point(line.end_point)
+      (start_sign < 0 && end_sign > 0) || (end_sign < 0 && start_sign > 0)
+    end
+
+    def intersect_line(line, target = Mittsu::Vector3.new)
+      v1 = Mittsu::Vector3.new
+      direction = line.delta(v1)
+      denominator = @normal.dot(direction)
+      if denominator.zero?
+        # line is coplanar, return origin
+        if self.distance_to_point(line.start_point).zero?
+          return target.copy(line.start_point)
+        end
+        # Unsure if this is the correct method to handle this case.
+        return nil
+      end
+      t = -(line.start_point.dot(@normal) + @constant) / denominator
+      return nil if t < 0 || t > 1
+      target.copy(direction).multiply_scalar(t).add(line.start_point)
+    end
+
+    def coplanar_point(target = Mittsu::Vector3.new)
+      target.copy(@normal).multiply_scalar(- @constant)
+    end
+
+    def apply_matrix4(matrix, normal_matrix = Mittsu::Matrix3.new.normal_matrix(matrix))
+      v1 = Mittsu::Vector3.new
+      v2 = Mittsu::Vector3.new
+      # compute new normal based on theory here:
+      # http:#www.songho.ca/opengl/gl_normaltransform.html
+      new_normal = v1.copy(@normal).apply_matrix3(normal_matrix)
+      new_coplanar_point = self.coplanar_point(v2)
+      new_coplanar_point.apply_matrix4(matrix)
+      self.set_from_normal_and_coplanar_point(new_normal, new_coplanar_point)
+      self
+    end
+
+    def translate(offset)
+      @constant = @constant - offset.dot(@normal)
+      self
+    end
+
+    def ==(plane)
+      plane.normal == @normal && plane.constant == @constant
+    end
+
+    def clone
+      Mittsu::Plane.new.copy(self)
+    end
+  end
+end

data/lib/mittsu/math/quaternion.rb

@@ -0,0 +1,309 @@
+require 'mittsu/math'
+
+module Mittsu
+  class Quaternion
+    EPS = 0.000001
+
+    attr_reader :x, :y, :z, :w
+
+    def initialize(x = 0.0, y = 0.0, z = 0.0, w = 1.0)
+      @x, @y, @z, @w = x, y, z, w
+    end
+
+    def set(x, y, z, w)
+      @x = x.to_f
+      @y = y.to_f
+      @z = z.to_f
+      @w = w.to_f
+      self.on_change_callback
+      self
+    end
+
+    def x=(x)
+      @x = x.to_f
+      self.on_change_callback
+    end
+
+    def y=(y)
+      @y = y.to_f
+      self.on_change_callback
+    end
+
+    def z=(z)
+      @z = z.to_f
+      self.on_change_callback
+    end
+
+    def w=(w)
+      @w = w.to_f
+      self.on_change_callback
+    end
+
+    def copy(quaternion)
+      @x = quaternion.x
+      @y = quaternion.y
+      @z = quaternion.z
+      @w = quaternion.w
+      self.on_change_callback
+      self
+    end
+
+    def set_from_euler(euler, update = true)
+      # http:#www.mathworks.com/matlabcentral/fileexchange/
+      #   20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/
+      #  content/SpinCalc.m
+      c1 = Math.cos(euler.x / 2.0)
+      c2 = Math.cos(euler.y / 2.0)
+      c3 = Math.cos(euler.z / 2.0)
+      s1 = Math.sin(euler.x / 2.0)
+      s2 = Math.sin(euler.y / 2.0)
+      s3 = Math.sin(euler.z / 2.0)
+      if euler.order == 'XYZ'
+        @x = s1 * c2 * c3 + c1 * s2 * s3
+        @y = c1 * s2 * c3 - s1 * c2 * s3
+        @z = c1 * c2 * s3 + s1 * s2 * c3
+        @w = c1 * c2 * c3 - s1 * s2 * s3
+      elsif euler.order == 'YXZ'
+        @x = s1 * c2 * c3 + c1 * s2 * s3
+        @y = c1 * s2 * c3 - s1 * c2 * s3
+        @z = c1 * c2 * s3 - s1 * s2 * c3
+        @w = c1 * c2 * c3 + s1 * s2 * s3
+      elsif euler.order == 'ZXY'
+        @x = s1 * c2 * c3 - c1 * s2 * s3
+        @y = c1 * s2 * c3 + s1 * c2 * s3
+        @z = c1 * c2 * s3 + s1 * s2 * c3
+        @w = c1 * c2 * c3 - s1 * s2 * s3
+      elsif euler.order == 'ZYX'
+        @x = s1 * c2 * c3 - c1 * s2 * s3
+        @y = c1 * s2 * c3 + s1 * c2 * s3
+        @z = c1 * c2 * s3 - s1 * s2 * c3
+        @w = c1 * c2 * c3 + s1 * s2 * s3
+      elsif euler.order == 'YZX'
+        @x = s1 * c2 * c3 + c1 * s2 * s3
+        @y = c1 * s2 * c3 + s1 * c2 * s3
+        @z = c1 * c2 * s3 - s1 * s2 * c3
+        @w = c1 * c2 * c3 - s1 * s2 * s3
+      elsif euler.order == 'XZY'
+        @x = s1 * c2 * c3 - c1 * s2 * s3
+        @y = c1 * s2 * c3 - s1 * c2 * s3
+        @z = c1 * c2 * s3 + s1 * s2 * c3
+        @w = c1 * c2 * c3 + s1 * s2 * s3
+      end
+      self.on_change_callback if update
+      self
+    end
+
+    def set_from_axis_angle(axis, angle)
+      # http:#www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm
+      # assumes axis is normalized
+      half_angle = angle / 2.0
+      s = Math.sin(half_angle)
+      @x = axis.x * s
+      @y = axis.y * s
+      @z = axis.z * s
+      @w = Math.cos(half_angle)
+      self.on_change_callback
+      self
+    end
+
+    def set_from_rotation_matrix(m)
+      # http:#www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
+      # assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
+      te = m.elements
+      m11 = te[0]; m12 = te[4]; m13 = te[8]
+      m21 = te[1]; m22 = te[5]; m23 = te[9]
+      m31 = te[2]; m32 = te[6]; m33 = te[10]
+      trace = m11 + m22 + m33
+      if trace > 0
+        s = 0.5 / Math.sqrt(trace + 1.0)
+        @w = 0.25 / s
+        @x = (m32 - m23) * s
+        @y = (m13 - m31) * s
+        @z = (m21 - m12) * s
+      elsif m11 > m22 && m11 > m33
+        s = 2.0 * Math.sqrt(1.0 + m11 - m22 - m33)
+        @w = (m32 - m23) / s
+        @x = 0.25 * s
+        @y = (m12 + m21) / s
+        @z = (m13 + m31) / s
+      elsif m22 > m33
+        s = 2.0 * Math.sqrt(1.0 + m22 - m11 - m33)
+        @w = (m13 - m31) / s
+        @x = (m12 + m21) / s
+        @y = 0.25 * s
+        @z = (m23 + m32) / s
+      else
+        s = 2.0 * Math.sqrt(1.0 + m33 - m11 - m22)
+        @w = (m21 - m12) / s
+        @x = (m13 + m31) / s
+        @y = (m23 + m32) / s
+        @z = 0.25 * s
+      end
+      self.on_change_callback
+      self
+    end
+
+    def set_from_unit_vectors(v_from, v_to)
+      # http:#lolengine.net/blog/2014/02/24/quaternion-from-two-vectors-final
+      # assumes direction vectors v_from and v_to are normalized
+      v1 = Mittsu::Vector3.new
+      r = v_from.dot(v_to) + 1.0
+      if r < EPS
+        r = 0.0
+        if v_from.x.abs > v_from.z.abs
+          v1.set(-v_from.y, v_from.x, 0.0)
+        else
+          v1.set(0.0, -v_from.z, v_from.y)
+        end
+      else
+        v1.cross_vectors(v_from, v_to)
+      end
+      @x = v1.x
+      @y = v1.y
+      @z = v1.z
+      @w = r
+      self.normalize
+      self
+    end
+
+    def inverse
+      self.conjugate.normalize
+      self
+    end
+
+    def conjugate
+      @x *= -1.0
+      @y *= -1.0
+      @z *= -1.0
+      self.on_change_callback
+      self
+    end
+
+    def dot(v)
+      @x * v._x + @y * v._y + @z * v._z + @w * v._w
+    end
+
+    def length_sq
+      @x * @x + @y * @y + @z * @z + @w * @w
+    end
+
+    def length
+      Math.sqrt(@x * @x + @y * @y + @z * @z + @w * @w)
+    end
+
+    def normalize
+      l = self.length
+      if l == 0.0
+        @x = 0.0
+        @y = 0.0
+        @z = 0.0
+        @w = 1.0
+      else
+        l = 1.0 / l
+        @x = @x * l
+        @y = @y * l
+        @z = @z * l
+        @w = @w * l
+      end
+      self.on_change_callback
+      self
+    end
+
+    def multiply(q)
+      self.multiply_quaternions(self, q)
+    end
+
+    def multiply_quaternions(a, b)
+      # from http:#www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
+      qax = a.x; qay = a.y; qaz = a.z; qaw = a.w
+      qbx = b.x; qby = b.y; qbz = b.z; qbw = b.w
+      @x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby
+      @y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz
+      @z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx
+      @w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz
+      self.on_change_callback
+      self
+    end
+
+    def slerp(qb, t)
+      return self if t.zero?
+      return self.copy(qb) if t == 1.0
+      _x, _y, _z, _w = @x, @y, @z, @w
+      # http:#www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/
+      cos_half_theta = _w * qb.w + _x * qb.x + _y * qb.y + _z * qb.z
+      if cos_half_theta < 0.0
+        @w = -qb.w
+        @x = -qb.x
+        @y = -qb.y
+        @z = -qb.z
+        cos_half_theta = - cos_half_theta
+      else
+        self.copy(qb)
+      end
+      if cos_half_theta >= 1.0
+        @w = _w
+        @x = _x
+        @y = _y
+        @z = _z
+        return self
+      end
+      half_theta = Math.acos(cos_half_theta)
+      sin_half_theta = Math.sqrt(1.0 - cos_half_theta * cos_half_theta)
+      if sin_half_theta.abs < 0.001
+        @w = 0.5 * (_w + @w)
+        @x = 0.5 * (_x + @x)
+        @y = 0.5 * (_y + @y)
+        @z = 0.5 * (_z + @z)
+        return self
+      end
+      ratio_a = Math.sin((1.0. - t) * half_theta) / sin_half_theta,
+      ratio_b = Math.sin(t * half_theta) / sin_half_theta
+      @w = (_w * ratio_a + @w * ratio_b)
+      @x = (_x * ratio_a + @x * ratio_b)
+      @y = (_y * ratio_a + @y * ratio_b)
+      @z = (_z * ratio_a + @z * ratio_b)
+      self.on_change_callback
+      self
+    end
+
+    def ==(quaternion)
+      (quaternion.x == @x) && (quaternion.y == @y) && (quaternion.z == @z) && (quaternion.w == @w)
+    end
+
+    def from_array(array, offset = 0)
+      @x = array[offset]
+      @y = array[offset + 1]
+      @z = array[offset + 2]
+      @w = array[offset + 3]
+      self.on_change_callback
+      self
+    end
+
+    def to_array(array = [], offset = 0)
+      array[offset] = @x
+      array[offset + 1] = @y
+      array[offset + 2] = @z
+      array[offset + 3] = @w
+      array
+    end
+
+    def on_change(&callback)
+      @on_change_callback = callback
+      self
+    end
+
+    def on_change_callback
+      return unless @on_change_callback
+      @on_change_callback.call
+    end
+
+    def clone
+      Mittsu::Quaternion.new(@x, @y, @z, @w)
+    end
+
+    def self.slerp(qa, qb, qm, t)
+      qm.copy(qa).slerp(qb, t)
+    end
+
+  end
+end

data/lib/mittsu/math/ray.rb

@@ -0,0 +1,292 @@
+require 'mittsu/math'
+
+module Mittsu
+  class Ray
+    attr_accessor :origin, :direction
+
+    def initialize(origin = Mittsu::Vector3.new, direction = Mittsu::Vector3.new)
+      @origin, @direction = origin, direction
+    end
+
+    def set(origin, direction)
+      @origin.copy(origin)
+      @direction.copy(direction)
+      self
+    end
+
+    def copy(ray)
+      @origin.copy(ray.origin)
+      @direction.copy(ray.direction)
+      self
+    end
+
+    def at(t, target = Mittsu::Vector3.new)
+      target.copy(@direction).multiply_scalar(t).add(@origin)
+    end
+
+    def recast(t)
+      v1 = Mittsu::Vector3.new
+      @origin.copy(self.at(t, v1))
+      self
+    end
+
+    def closest_point_to_point(point, target = Mittsu::Vector3.new)
+      target.sub_vectors(point, @origin)
+      direction_distance = target.dot(@direction)
+      if direction_distance < 0
+        return target.copy(@origin)
+      end
+      target.copy(@direction).multiply_scalar(direction_distance).add(@origin)
+    end
+
+    def distance_to_point(point)
+      v1 = Mittsu::Vector3.new
+      direction_distance = v1.sub_vectors(point, @origin).dot(@direction)
+      # point behind the ray
+      if direction_distance < 0
+        return @origin.distance_to(point)
+      end
+      v1.copy(@direction).multiply_scalar(direction_distance).add(@origin)
+      v1.distance_to(point)
+    end
+
+    def distance_sq_to_segment(v0, v1, point_on_ray = nil, point_on_segment = nil)
+      seg_center = Mittsu::Vector3.new
+      seg_dir = Mittsu::Vector3.new
+      diff = Mittsu::Vector3.new
+      # from http:#www.geometrictools.com/LibMathematics/Distance/Wm5DistRay3Segment3.cpp
+      # It returns the min distance between the ray and the segment
+      # defined by v0 and v1
+      # It can also set two optional targets :
+      # - The closest point on the ray
+      # - The closest point on the segment
+      seg_center.copy(v0).add(v1).multiply_scalar(0.5)
+      seg_dir.copy(v1).sub(v0).normalize
+      diff.copy(@origin).sub(seg_center)
+      seg_extent = v0.distance_to(v1) * 0.5
+      a01 = -@direction.dot(seg_dir)
+      b0 = diff.dot(@direction)
+      b1 = -diff.dot(seg_dir)
+      c = diff.length_sq
+      det = (1.0 - a01 * a01).abs
+      if det > 0
+        # The ray and segment are not parallel.
+        s0 = a01 * b1 - b0
+        s1 = a01 * b0 - b1
+        ext_det = seg_extent * det
+        if s0 >= 0
+          if s1 >= -ext_det
+            if s1 <= ext_det
+              # region 0
+              # Minimum at interior points of ray and segment.
+              inv_det = 1.0 / det
+              s0 *= inv_det
+              s1 *= inv_det
+              sqr_dist = s0 * (s0 + a01 * s1 + 2.0 * b0) + s1 * (a01 * s0 + s1 + 2.0 * b1) + c
+            else
+              # region 1
+              s1 = seg_extent
+              s0 = [0.0, -(a01 * s1 + b0)].max
+              sqr_dist = - s0 * s0 + s1 * (s1 + 2.0 * b1) + c
+            end
+          else
+            # region 5
+            s1 = - seg_extent
+            s0 = [0.0, -(a01 * s1 + b0)].max
+            sqr_dist = -s0 * s0 + s1 * (s1 + 2.0 * b1) + c
+          end
+        else
+          if s1 <= - ext_det
+            # region 4
+            s0 = [0.0, -(-a01 * seg_extent + b0)].max
+            s1 = (s0 > 0) ? -seg_extent : [[-seg_extent, -b1].max, seg_extent].min
+            sqr_dist = - s0 * s0 + s1 * (s1 + 2 * b1) + c
+          elsif s1 <= ext_det
+            # region 3
+            s0 = 0.0
+            s1 = [[-seg_extent, -b1].max, seg_extent].min
+            sqr_dist = s1 * (s1 + 2.0 * b1) + c
+          else
+            # region 2
+            s0 = [0.0, -(a01 * seg_extent + b0)].max
+            s1 = (s0 > 0) ? seg_extent : [[-seg_extent, -b1].max, seg_extent].min
+            sqr_dist = -s0 * s0 + s1 * (s1 + 2.0 * b1) + c
+          end
+        end
+      else
+        # Ray and segment are parallel.
+        s1 = (a01 > 0) ? -seg_extent : seg_extent
+        s0 = [0.0, -(a01 * s1 + b0)].max
+        sqr_dist = -s0 * s0 + s1 * (s1 + 2.0 * b1) + c
+      end
+      if point_on_ray
+        point_on_ray.copy(@direction).multiply_scalar(s0).add(@origin)
+      end
+      if point_on_segment
+        point_on_segment.copy(seg_dir).multiply_scalar(s1).add(seg_center)
+      end
+      sqr_dist
+    end
+
+    def intersection_sphere?(sphere)
+      self.distance_to_point(sphere.center) <= sphere.radius
+    end
+
+    def intersect_sphere(sphere, target = Mittsu::Vector3.new)
+      # from http:#www.scratchapixel.com/lessons/3d-basic-lessons/lesson-7-intersecting-simple-shapes/ray-sphere-intersection/
+      v1 = Mittsu::Vector3.new
+      v1.sub_vectors(sphere.center, @origin)
+      tca = v1.dot(@direction)
+      d2 = v1.dot(v1) - tca * tca
+      radius2 = sphere.radius * sphere.radius
+      return nil if d2 > radius2
+      thc = Math.sqrt(radius2 - d2)
+      # t0 = first intersect point - entrance on front of sphere
+      t0 = tca - thc
+      # t1 = second intersect point - exit point on back of sphere
+      t1 = tca + thc
+      # test to see if both t0 and t1 are behind the ray - if so, return nil
+      return nil if t0 < 0 && t1 < 0
+      # test to see if t0 is behind the ray:
+      # if it is, the ray is inside the sphere, so return the second exit point scaled by t1,
+      # in order to always return an intersect point that is in front of the ray.
+      return self.at(t1, target) if t0 < 0
+      # else t0 is in front of the ray, so return the first collision point scaled by t0
+      self.at(t0, target)
+    end
+
+    def intersection_plane?(plane)
+      # check if the ray lies on the plane first
+      dist_to_point = plane.distance_to_point(@origin)
+      return true if dist_to_point.zero?
+      denominator = plane.normal.dot(@direction)
+      return true if denominator * dist_to_point < 0
+      # ray origin is behind the plane (and is pointing behind it)
+      false
+    end
+
+    def distance_to_plane(plane)
+      denominator = plane.normal.dot(@direction)
+      if denominator.zero?
+        # line is coplanar, return origin
+        return 0.0 if plane.distance_to_point(@origin).zero?
+        # Null is preferable to nil since nil means.... it is nil
+        return nil
+      end
+      t = -(@origin.dot(plane.normal) + plane.constant) / denominator
+      # Return if the ray never intersects the plane
+      t >= 0 ? t : nil
+    end
+
+    def intersect_plane(plane, target = Mittsu::Vector3.new)
+      t = self.distance_to_plane(plane)
+      return nil if t.nil?
+      self.at(t, target)
+    end
+
+    def intersection_box?(box)
+      v = Mittsu::Vector3.new
+      !self.intersect_box(box, v).nil?
+    end
+
+    def intersect_box(box, target = Mittsu::Vector3.new)
+      # http:#www.scratchapixel.com/lessons/3d-basic-lessons/lesson-7-intersecting-simple-shapes/ray-box-intersection/
+      invdirx = 1.0 / @direction.x
+      invdiry = 1.0 / @direction.y
+      invdirz = 1.0 / @direction.z
+      origin = @origin
+      if invdirx >= 0
+        tmin = (box.min.x - origin.x) * invdirx
+        tmax = (box.max.x - origin.x) * invdirx
+      else
+        tmin = (box.max.x - origin.x) * invdirx
+        tmax = (box.min.x - origin.x) * invdirx
+      end
+      if invdiry >= 0
+        tymin = (box.min.y - origin.y) * invdiry
+        tymax = (box.max.y - origin.y) * invdiry
+      else
+        tymin = (box.max.y - origin.y) * invdiry
+        tymax = (box.min.y - origin.y) * invdiry
+      end
+      return nil if tmin > tymax || tymin > tmax
+      # These lines also handle the case where tmin or tmax is NaN
+      # (result of 0 * Infinity). x != x returns true if x is NaN
+      tmin = tymin if tymin > tmin || tmin != tmin
+      tmax = tymax if tymax < tmax || tmax != tmax
+      if invdirz >= 0
+        tzmin = (box.min.z - origin.z) * invdirz
+        tzmax = (box.max.z - origin.z) * invdirz
+      else
+        tzmin = (box.max.z - origin.z) * invdirz
+        tzmax = (box.min.z - origin.z) * invdirz
+      end
+      return nil if tmin > tzmax || tzmin > tmax
+      tmin = tzmin if tzmin > tmin || tmin != tmin
+      tmax = tzmax if tzmax < tmax || tmax != tmax
+      #return point closest to the ray (positive side)
+      return nil if tmax < 0
+      self.at(tmin >= 0 ? tmin : tmax, target)
+    end
+
+    def intersect_triangle(a, b, c, backface_culling, target = Mittsu::Vector3.new)
+      # Compute the offset origin, edges, and normal.
+      diff = Mittsu::Vector3.new
+      edge1 = Mittsu::Vector3.new
+      edge2 = Mittsu::Vector3.new
+      normal = Mittsu::Vector3.new
+      # from http:#www.geometrictools.com/LibMathematics/Intersection/Wm5IntrRay3Triangle3.cpp
+      edge1.sub_vectors(b, a)
+      edge2.sub_vectors(c, a)
+      normal.cross_vectors(edge1, edge2)
+      # Solve Q + t*D = b1*E1 + b2*E2 (Q = kDiff, D = ray direction,
+      # E1 = kEdge1, E2 = kEdge2, N = Cross(E1,E2)) by
+      #   |Dot(D,N)|*b1 = sign(Dot(D,N))*Dot(D,Cross(Q,E2))
+      #   |Dot(D,N)|*b2 = sign(Dot(D,N))*Dot(D,Cross(E1,Q))
+      #   |Dot(D,N)|*t = -sign(Dot(D,N))*Dot(Q,N)
+      d_dot_n = @direction.dot(normal)
+      sign
+      if d_dot_n > 0
+        return nil if backface_culling
+        sign = 1.0
+      elsif d_dot_n < 0
+        sign = -1.0
+        d_dot_n = - d_dot_n
+      else
+        return nil
+      end
+      diff.sub_vectors(@origin, a)
+      d_dot_q_x_e2 = sign * @direction.dot(edge2.cross_vectors(diff, edge2))
+      # b1 < 0, no intersection
+      return nil if d_dot_q_x_e2 < 0
+      d_dot_e1_x_q = sign * @direction.dot(edge1.cross(diff))
+      # b2 < 0, no intersection
+      return nil if d_dot_e1_x_q < 0
+      # b1+b2 > 1, no intersection
+      return nil if d_dot_q_x_e2 + d_dot_e1_x_q > d_dot_n
+      # Line intersects triangle, check if ray does.
+      q_dot_n = -sign * diff.dot(normal)
+      # t < 0, no intersection
+      return nil if q_dot_n < 0
+      # Ray intersects triangle.
+      self.at(q_dot_n / d_dot_n, target)
+    end
+
+    def apply_matrix4(matrix4)
+      @direction.add(@origin).apply_matrix4(matrix4)
+      @origin.apply_matrix4(matrix4)
+      @direction.sub(@origin)
+      @direction.normalize
+      self
+    end
+
+    def ==(ray)
+      ray.origin == @origin && ray.direction == @direction
+    end
+
+    def clone
+      Mittsu::Ray.new.copy(self)
+    end
+
+  end
+end