mittsu 0.1.1 → 0.1.2

data/lib/mittsu/math/matrix3.rb

@@ -3,7 +3,10 @@ require 'mittsu/math'
 module Mittsu
   class Matrix3
     attr_accessor :elements
-    def initialize
+
+    DIMENSIONS = 3
+
+    def initialize()
       @elements = [
         1.0, 0.0, 0.0,
         0.0, 1.0, 0.0,
@@ -141,6 +144,10 @@ module Mittsu
       self
     end
 
+    def ==(other)
+      other.elements == @elements
+    end
+
     def from_array(array)
       self.elements[0..array.length] = (array)
       self

data/lib/mittsu/math/matrix4.rb

@@ -4,6 +4,8 @@ module Mittsu
   class Matrix4
     attr_accessor :elements
 
+    DIMENSIONS = 4
+
     def initialize()
       @elements = [
         1.0, 0.0, 0.0, 0.0,
@@ -563,6 +565,10 @@ module Mittsu
       self
     end
 
+    def ==(other)
+      other.elements == @elements
+    end
+
     def to_a
       te = self.elements
       [

data/lib/mittsu/math/vector.rb

@@ -0,0 +1,251 @@
+module Mittsu
+  class Vector
+    attr_accessor :elements
+
+    def initialize(elements)
+      @elements = elements
+    end
+
+    def set(elements)
+      @elements = elements
+      self
+    end
+
+    def each_dimension
+      self.class::DIMENSIONS.times do |i|
+        yield i
+      end
+    end
+
+    def []=(index, value)
+      index = self.class::ELEMENTS[index] if index.is_a?(Symbol)
+      raise IndexError if index.nil? || index < 0 || index >= self.class::DIMENSIONS
+      @elements[index] = value
+    end
+
+    def [](index)
+      index = self.class::ELEMENTS[index] if index.is_a?(Symbol)
+      raise IndexError if index.nil? || index < 0 || index >= self.class::DIMENSIONS
+      @elements[index]
+    end
+
+    def copy(v)
+      @elements = v.elements.dup
+      self
+    end
+
+    def add(v)
+      each_dimension do |i|
+        @elements[i] = @elements[i] + v.elements[i]
+      end
+      self
+    end
+
+    def add_scalar(s)
+      @elements.map!{ |e| e + s }
+      self
+    end
+
+    def add_vectors(a, b)
+      each_dimension do |i|
+        @elements[i] = a.elements[i] + b.elements[i]
+      end
+      self
+    end
+
+    def sub(v)
+      each_dimension do |i|
+        @elements[i] = @elements[i] - v.elements[i]
+      end
+      self
+    end
+
+    def sub_scalar(s)
+      @elements.map!{ |e| e - s }
+      self
+    end
+
+    def sub_vectors(a, b)
+      each_dimension do |i|
+        @elements[i] = a.elements[i] - b.elements[i]
+      end
+      self
+    end
+
+    def multiply(v)
+      each_dimension do |i|
+        @elements[i] = @elements[i] * v.elements[i]
+      end
+      self
+    end
+
+    def multiply_scalar(s)
+      @elements.map!{ |e| e * s }
+      self
+    end
+
+    def multiply_vectors(a, b)
+      each_dimension do |i|
+        @elements[i] = a.elements[i] * b.elements[i]
+      end
+      self
+    end
+
+    def divide(v)
+      each_dimension do |i|
+        @elements[i] = @elements[i] / v.elements[i]
+      end
+      self
+    end
+
+    def divide_scalar(s)
+      inv_scalar = s == 0 ? 0 : 1.0 / s
+      @elements.map!{ |e| e * inv_scalar }
+      self
+    end
+
+    def min(v)
+      each_dimension do |i|
+        @elements[i] = v.elements[i] if @elements[i] > v.elements[i]
+      end
+      self
+    end
+
+    def max(v)
+      each_dimension do |i|
+        @elements[i] = v.elements[i] if @elements[i] < v.elements[i]
+      end
+      self
+    end
+
+    def clamp(min, max)
+      each_dimension do |i|
+        @elements[i] = Math.clamp(@elements[i], min.elements[i], max.elements[i])
+      end
+      self
+    end
+
+    def clamp_scalar(min, max)
+      @elements.map!{ |e| Math.clamp(e, min, max) }
+      self
+    end
+
+    def floor
+      @elements.map!{ |e| e.floor.to_f }
+      self
+    end
+
+    def ceil
+      @elements.map!{ |e| e.ceil.to_f }
+      self
+    end
+
+    def round
+      @elements.map!{ |e| e.round.to_f }
+      self
+    end
+
+    def round_to_zero
+      @elements.map!{ |e| (e < 0) ? e.ceil.to_f : e.floor.to_f }
+      self
+    end
+
+    def negate
+      @elements.map!{ |e| -e }
+      self
+    end
+
+    def length_sq
+      self.dot(self)
+    end
+
+    def length
+      Math.sqrt(length_sq)
+    end
+
+    def normalize
+      self.divide_scalar(self.length)
+    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)
+      each_dimension do |i|
+        @elements[i] += (v.elements[i] - @elements[i]) * alpha
+      end
+      self
+    end
+
+    def lerp_vectors(v1, v2, alpha)
+      self.sub_vectors(v2, v1).multiply_scalar(alpha).add(v1)
+      self
+    end
+
+    def project_on_vector(vector)
+      v1 = self.class.new
+      v1.copy(vector).normalize
+      dot = self.dot(v1)
+      self.copy(v1).multiply_scalar(dot)
+    end
+
+    def project_on_plane(plane_normal)
+      v1 = self.class.new
+      v1.copy(self).project_on_vector(plane_normal)
+      self.sub(v1)
+    end
+
+    def reflect(normal)
+      # reflect incident vector off plane orthogonal to normal
+      # normal is assumed to have unit length
+      v1 = self.class.new
+      self.sub(v1.copy(normal).multiply_scalar(2.0 * self.dot(normal)))
+    end
+
+    def angle_to(v)
+      theta = self.dot(v) / (self.length * v.length)
+
+      # clamp, to handle numerical problems
+      Math.acos(Math.clamp(theta, -1.0, 1.0))
+    end
+
+    def distance_to(v)
+      Math.sqrt(self.distance_to_squared(v))
+    end
+
+    def ==(v)
+      each_dimension do |i|
+        return false if @elements[i] != v.elements[i]
+      end
+      true
+    end
+
+    def from_array(array, offset = 0)
+      each_dimension do |i|
+        @elements[i] = array[offset + i]
+      end
+      self
+    end
+
+    def to_array(array = [], offset = 0)
+      each_dimension do |i|
+        array[offset + i] = @elements[i]
+      end
+      array
+    end
+    alias :to_a :to_array
+
+    def clone
+      self.class.new(*@elements)
+    end
+
+    def to_s
+      "[#{@elements.join(', ')}]"
+    end
+  end
+end

data/lib/mittsu/math/vector2.rb

@@ -1,238 +1,39 @@
 require 'mittsu/math'
+require 'mittsu/math/vector'
 
 module Mittsu
-  class Vector2
-    attr_reader :x, :y
+  class Vector2 < Vector
+    ELEMENTS = { x: 0, y: 1 }
+    DIMENSIONS = ELEMENTS.count
 
     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
+      super [x.to_f, y.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
+      super [x.to_f, y.to_f]
     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 x; @elements[0]; end
+    def y; @elements[1]; end
 
-    def negate
-      @x = -@x
-      @y = -@y
-      self
-    end
+    def x=(value); @elements[0] = value.to_f; end
+    def y=(value); @elements[1] = value.to_f; 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))
+      x * v.x + y * v.y
     end
 
     def distance_to_squared(v)
-      dx, dy = @x - v.x, @y - v.y
+      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]
+      @elements[0] = attribute.array[index]
+      @elements[1] = attribute.array[index + 1]
       self
     end
-
-    def clone
-      Vector2.new(@x, @y)
-    end
-
-    def to_s
-      "[#{x}, #{y}]"
-    end
   end
 end