mittsu 0.1.0

data/lib/mittsu/math/sphere.rb

@@ -0,0 +1,91 @@
+require 'mittsu/math'
+
+module Mittsu
+  class Sphere
+    attr_accessor :center, :radius
+
+    def initialize(center = Mittsu::Vector3.new, radius = 0.0)
+      @center, @radius = center, radius.to_f
+    end
+
+    def set(center, radius)
+      @center.copy(center)
+      @radius = radius.to_f
+      self
+    end
+
+    def set_from_points(points, optional_center = nil)
+      box = Mittsu::Box3.new
+      c = @center
+      if optional_center.nil?
+        box.set_from_points(points).center(c)
+      else
+        c.copy(optional_center)
+      end
+      max_radius_sq = 0.0
+      points.each do |point|
+        max_radius_sq = [max_radius_sq, c.distance_to_squared(point)].max
+      end
+      @radius = Math.sqrt(max_radius_sq)
+      self
+    end
+
+    def copy(sphere)
+      @center.copy(sphere.center)
+      @radius = sphere.radius
+      self
+    end
+
+    def empty
+      @radius <= 0
+    end
+
+    def contains_point?(point)
+      point.distance_to_squared(@center) <= @radius * @radius
+    end
+
+    def distance_to_point(point)
+      point.distance_to(@center) - @radius
+    end
+
+    def intersects_sphere?(sphere)
+      radiusSum = @radius + sphere.radius
+      sphere.center.distance_to_squared(@center) <= radiusSum * radiusSum
+    end
+
+    def clamp_point(point, target = Mittsu::Vector3.new)
+      delta_length_sq = @center.distance_to_squared(point)
+      target.copy(point)
+      if delta_length_sq > (@radius * @radius)
+        target.sub(@center).normalize
+        target.multiply_scalar(@radius).add(@center)
+      end
+      target
+    end
+
+    def bounding_box(target = Mittsu::Box3.new)
+      target.set(@center, @center)
+      target.expand_by_scalar(@radius)
+      target
+    end
+
+    def apply_matrix4(matrix)
+      @center.apply_matrix4(matrix)
+      @radius = @radius * matrix.max_scale_on_axis
+      self
+    end
+
+    def translate(offset)
+      @center.add(offset)
+      self
+    end
+
+    def ==(sphere)
+      sphere.center == (@center) && sphere.radius == @radius
+    end
+
+    def clone
+      Mittsu::Sphere.new.copy(self)
+    end
+  end
+end

data/lib/mittsu/math/spline.rb

@@ -0,0 +1,128 @@
+require 'mittsu/math'
+
+module Mittsu
+  class Spline
+    Point = Struct.new(:x, :y, :z)
+    Length = Struct.new(:chunks, :total)
+
+    attr_accessor :points
+
+    def initialize(points)
+      @points = points
+      @c = []
+      @v3 = Point.new(0.0, 0.0, 0.0)
+    end
+
+    def init_from_array(a)
+      @points = a.map do |p|
+        Point.new(*p.take(3))
+      end
+    end
+
+    def point(k)
+      point = (@points.length - 1) * k
+      int_point = point.floor
+      weight = point - int_point
+
+      @c[0] = int_point.zero? ? int_point : int_point - 1
+      @c[1] = int_point
+      @c[2] = int_point > @points.length - 1 ? @points.length - 1 : int_point + 1
+      @c[3] = int_point > @points.length - 3 ? @points.length - 1 : int_point + 2
+
+      pa = @points[c[0]]
+      pb = @points[c[1]]
+      pc = @points[c[2]]
+      pd = @points[c[3]]
+
+      w2 = weight * weight
+      w3 = weight * w2
+
+      v3.x = interpolate(pa.x, pb.x, pc.x, pd.x, weight, w2, w3)
+      v3.y = interpolate(pa.y, pb.y, pc.y, pd.y, weight, w2, w3)
+      v3.z = interpolate(pa.z, pb.z, pc.z, pd.z, weight, w2, w3)
+
+      v3
+    end
+
+    def control_points_array
+      @points.map do |p|
+        [ p.x, p.y, p.z ]
+      end
+    end
+
+    def length(n_sub_divisions = 100)
+      point, int_point, old_int_point = 0, 0, 0
+      old_position = Mittsu::Vector3.new
+      tmp_vec = Mittsu::Vector3.new
+      chunk_lengths = []
+      total_length = 0
+
+      # first point has 0 length
+      chunk_lengths << 0
+      n_samples = @points.length * n_sub_divisions
+      old_position.copy(@points.first)
+
+      (1...n_samples).each do |i|
+        index = i.to_f / n_samples.to_f
+
+        position = self.point(index)
+        tmp_vec.copy(position)
+
+        total_length += tmp_vec.distance_to(old_position)
+
+        old_position.copy(position)
+
+        point = (@points.length - 1) * index
+        int_point = point.floor
+
+        if (int_point != old_int_point)
+          chunk_lengths[int_point] = total_length
+          old_int_point = int_point
+        end
+      end
+
+      # last point ends with total length
+      chunk_lengths << total_length
+      Length.new(chunk_lengths, total_length)
+    end
+
+    def reparametrize_by_arc_length(sampling_coef)
+      new_points = []
+      tmp_vec = Mittsu::Vector3.new
+      sl = self.length
+
+      new_points << tmp_vec.copy(@points[0]).clone
+
+      @points.each_with_index do |p,i|
+        #tmp_vec.copy(@points[i-1])
+        #linear_distance = tmp_vec.distance_to(p)
+
+        real_distance = sl.chunks[i] - sl.chunks[i - 1]
+
+        sampling = (sampling_coef * real_distance / sl.total).ceil
+
+        index_current = (i.to_f - 1.0) / (@points.length.to_f - 1.0)
+        index_next = i.to_f / (@points.length.to_f - 1.0)
+
+        (1...sampling-1).each do |j|
+          index = index_current + j * (1.0 / sampling) * (index_next - index_current)
+
+          position = self.point(index)
+          new_points << tmp_vec.copy(position).clone
+        end
+
+        new_points << tmp_vec.copy(p).clone
+      end
+      @points = new_points
+    end
+
+    private
+
+    def interpolate(p0, p1, p2, p3, t, t2, t3)
+      v0 = (p2 - p0) * 0.5
+      v1 = (p4 - p1) * 0.5
+
+      (2.0 * (p1 - p2) + v0 + v1) * t3 + (-3.0 * (p1 - p2) - 2.0 * v0 - v1) * t2 + v0 * t + p1?
+    end
+  end
+end

data/lib/mittsu/math/triangle.rb

@@ -0,0 +1,121 @@
+require 'mittsu/math'
+
+module Mittsu
+  class Triangle
+    attr_accessor :a, :b, :c
+
+    def initialize(a = Mittsu::Vector3.new, b = Mittsu::Vector3.new, c = Mittsu::Vector3.new)
+      @a, @b, @c = a, b, c
+    end
+
+    def set(a, b, c)
+      @a.copy(a)
+      @b.copy(b)
+      @c.copy(c)
+      self
+    end
+
+    def set_from_points_and_indices(points, i0, i1, i2)
+      @a.copy(points[i0])
+      @b.copy(points[i1])
+      @c.copy(points[i2])
+      self
+    end
+
+    def copy(triangle)
+      @a.copy(triangle.a)
+      @b.copy(triangle.b)
+      @c.copy(triangle.c)
+      self
+    end
+
+    def area
+      v0 = Mittsu::Vector3.new
+      v1 = Mittsu::Vector3.new
+      v0.sub_vectors(@c, @b)
+      v1.sub_vectors(@a, @b)
+      v0.cross(v1).length * 0.5
+    end
+
+    def midpoint(target = Mittsu::Vector3.new)
+      target.add_vectors(@a, @b).add(@c).multiply_scalar(1.0 / 3.0)
+    end
+
+    def normal(target = Mittsu::Vector3.new)
+      Mittsu::Triangle.normal(@a, @b, @c, target)
+    end
+
+    def plane(target = Mittsu::Plane.new)
+      target.set_from_coplanar_points(@a, @b, @c)
+    end
+
+    def barycoord_from_point(point, target = Mittsu::Vector3.new)
+      Mittsu::Triangle.barycoord_from_point(point, @a, @b, @c, target)
+    end
+
+    def contains_point?(point)
+      Mittsu::Triangle.contains_point?(point, @a, @b, @c)
+    end
+
+    def equals(triangle)
+      triangle.a.equals(@a) && triangle.b.equals(@b) && triangle.c.equals(@c)
+    end
+
+    def clone
+      Mittsu::Triangle.new.copy(self)
+    end
+
+    def self.normal(a, b, c, target = Mittsu::Vector3.new)
+      v0 = Mittsu::Vector3.new
+      target.sub_vectors(c, b)
+      v0.sub_vectors(a, b)
+      target.cross(v0)
+
+      result_length_sq = target.length_sq
+      if (result_length_sq > 0)
+        target.multiply_scalar(1.0 / Math.sqrt(result_length_sq))
+      else
+        target.set(0.0, 0.0, 0.0)
+      end
+    end
+
+    # static/instance method to calculate barycoordinates
+    # based on: http://www.blackpawn.com/texts/pointinpoly/default.html
+    def self.barycoord_from_point(point, a, b, c, target = Mittsu::Vector3.new)
+      v0 = Mittsu::Vector3.new
+      v1 = Mittsu::Vector3.new
+      v2 = Mittsu::Vector3.new
+
+      v0.sub_vectors(c, a)
+      v1.sub_vectors(b, a)
+      v2.sub_vectors(point, a)
+
+      dot00 = v0.dot(v0)
+      dot01 = v0.dot(v1)
+      dot02 = v0.dot(v2)
+      dot11 = v1.dot(v1)
+      dot12 = v1.dot(v2)
+
+      denom = dot00 * dot11 - dot01 * dot01
+
+      # colinear or singular triangle
+      if denom.zero?
+        # arbitrary location outside of triangle?
+        # not sure if this is the best idea, maybe should be returning undefined
+        return target.set(-2.0, -1.0, -1.0)
+      end
+
+      inv_denom = 1.0 / denom
+      u = (dot11 * dot02 - dot01 * dot12) * inv_denom
+      v = (dot00 * dot12 - dot01 * dot02) * inv_denom
+
+      target.set(1.0 - u - v, v, u)
+    end
+
+    def self.contains_point?(point, a, b, c)
+      v1 = Mittsu::Vector3.new
+      result = Mittsu::Triangle.barycoord_from_point(point, a, b, c, v1)
+      result.x >= 0 && result.y >= 0 && result.x + result.y <= 1
+    end
+  end
+end

data/lib/mittsu/math/vector2.rb

@@ -0,0 +1,238 @@
+require 'mittsu/math'
+
+module Mittsu
+  class Vector2
+    attr_reader :x, :y
+
+    def initialize(x = 0, y = 0)
+      @x = x.to_f
+      @y = y.to_f
+    end
+
+    def x=(value)
+      @x = value.to_f
+    end
+
+    def y=(value)
+      @y = value.to_f
+    end
+
+    def set(x, y)
+      @x = x.to_f
+      @y = y.to_f
+      self
+    end
+
+    def []=(index, value)
+      return @x = value.to_f if index == 0
+      return @y = value.to_f if index == 1
+      raise IndexError
+    end
+
+    def [](index)
+      return @x if index == 0
+      return @y if index == 1
+      raise IndexError
+    end
+
+    def copy(v)
+      @x = v.x
+      @y = v.y
+      self
+    end
+
+    def add(v)
+      @x += v.x
+      @y += v.y
+      self
+    end
+
+    def add_scalar(s)
+      @x += s
+      @y += s
+      self
+    end
+
+    def add_vectors(a, b)
+      @x = a.x + b.x
+      @y = a.y + b.y
+      self
+    end
+
+    def sub(v)
+      @x -= v.x
+      @y -= v.y
+      self
+    end
+
+    def sub_scalar(s)
+      @x -= s
+      @y -= s
+      self
+    end
+
+    def sub_vectors(a, b)
+      @x = a.x - b.x
+      @y = a.y - b.y
+      self
+    end
+
+    def multiply(v)
+      @x *= v.x
+      @y *= v.y
+      self
+    end
+
+    def multiply_scalar(s)
+      @x *= s
+      @y *= s
+      self
+    end
+
+    def divide(v)
+      @x /= v.x
+      @y /= v.y
+      self
+    end
+
+    def divide_scalar(s)
+      @x /= s
+      @y /= s
+      self
+    end
+
+    def min(v)
+      @x = [@x, v.x].min
+      @y = [@y, v.y].min
+      self
+    end
+
+    def max(v)
+      @x = [@x, v.x].max
+      @y = [@y, v.y].max
+      self
+    end
+
+    def clamp(min, max)
+      @x = Math.clamp(@x, min.x, max.x)
+      @y = Math.clamp(@y, min.y, max.y)
+      self
+    end
+
+    def clamp_scalar(min, max)
+      min, max = min.to_f, max.to_f
+      @x = Math.clamp(@x, min, max)
+      @y = Math.clamp(@y, min, max)
+      self
+    end
+
+    def floor
+      @x = @x.floor.to_f
+      @y = @y.floor.to_f
+      self
+    end
+
+    def ceil
+      @x = @x.ceil.to_f
+      @y = @y.ceil.to_f
+      self
+    end
+
+    def round
+      @x = @x.round.to_f
+      @y = @y.round.to_f
+      self
+    end
+
+    def round_to_zero
+      @x = ( @x < 0 ) ? @x.ceil.to_f : @x.floor.to_f
+      @y = ( @y < 0 ) ? @y.ceil.to_f : @y.floor.to_f
+      self
+    end
+
+    def negate
+      @x = -@x
+      @y = -@y
+      self
+    end
+
+    def dot(v)
+      @x * v.x + @y * v.y
+    end
+
+    def length
+      Math.sqrt(length_sq)
+    end
+
+    def length_sq
+      self.dot(self)
+    end
+
+    def normalize
+      self.divide_scalar(self.length)
+    end
+
+    def distance_to(v)
+      Math.sqrt(distance_to_squared(v))
+    end
+
+    def distance_to_squared(v)
+      dx, dy = @x - v.x, @y - v.y
+      dx * dx + dy * dy
+    end
+
+    def set_length(l)
+      old_length = self.length
+      if old_length != 0 && l != old_length
+        self.multiply_scalar(l / old_length)
+      end
+      self
+    end
+
+    def lerp(v, alpha)
+      @x += (v.x - @x) * alpha
+      @y += (v.y - @y) * alpha
+      self
+    end
+
+    def lerp_vectors(v1, v2, alpha)
+      self.sub_vectors(v2, v1).multiply_scalar(alpha).add(v1);
+    end
+
+    def ==(v)
+      v.x == @x && v.y == @y
+    end
+
+    def from_array(array, offset = 0)
+      @x = array[offset]
+      @y = array[offset + 1]
+      self
+    end
+
+    def to_array(array = [], offset = 0)
+      array.tap { |a|
+        a[offset] = @x;
+        a[offset + 1] = @y;
+      }
+    end
+
+    def to_a
+      self.to_array
+    end
+
+    def from_attribute(attribute, index, offset = 0)
+      index = index * attribute.item_size + offset
+      @x = attribute.array[index]
+      @y = attribute.array[index + 1]
+      self
+    end
+
+    def clone
+      Vector2.new(@x, @y)
+    end
+
+    def to_s
+      "[#{x}, #{y}]"
+    end
+  end
+end