mittsu 0.1.1 → 0.1.2

data/lib/mittsu/math/vector3.rb

@@ -1,117 +1,26 @@
 require 'mittsu/math'
+require 'mittsu/math/vector'
 
 module Mittsu
-  class Vector3
-    attr_reader :x, :y, :z
+  class Vector3 < Vector
+    ELEMENTS = { x: 0, y: 1, z: 2 }
+    DIMENSIONS = ELEMENTS.count
 
     def initialize(x = 0, y = 0, z = 0)
-      @x = x.to_f
-      @y = y.to_f
-      @z = z.to_f
-    end
-
-    def x=(value)
-      @x = value.to_f
-    end
-
-    def y=(value)
-      @y = value.to_f
-    end
-
-    def z=(value)
-      @z = value.to_f
+      super [x.to_f, y.to_f, z.to_f]
     end
 
     def set(x, y, z)
-      @x = x.to_f
-      @y = y.to_f
-      @z = z.to_f
-      self
-    end
-
-    def []=(index, value)
-      return @x = value.to_f if index == 0 || index == :x
-      return @y = value.to_f if index == 1 || index == :y
-      return @z = value.to_f if index == 2 || index == :z
-      raise IndexError
-    end
-
-    def [](index)
-      return @x if index == 0 || index == :x
-      return @y if index == 1 || index == :y
-      return @z if index == 2 || index == :z
-      raise IndexError
-    end
-
-    def copy(v)
-      @x = v.x
-      @y = v.y
-      @z = v.z
-      self
-    end
-
-    def add(v)
-      @x += v.x
-      @y += v.y
-      @z += v.z
-      self
-    end
-
-    def add_scalar(s)
-      @x += s
-      @y += s
-      @z += s
-      self
+      super [x.to_f, y.to_f, z.to_f]
     end
 
-    def add_vectors(a, b)
-      @x = a.x + b.x
-      @y = a.y + b.y
-      @z = a.z + b.z
-      self
-    end
+    def x; @elements[0]; end
+    def y; @elements[1]; end
+    def z; @elements[2]; end
 
-    def sub(v)
-      @x -= v.x
-      @y -= v.y
-      @z -= v.z
-      self
-    end
-
-    def sub_scalar(s)
-      @x -= s
-      @y -= s
-      @z -= s
-      self
-    end
-
-    def sub_vectors(a, b)
-      @x = a.x - b.x
-      @y = a.y - b.y
-      @z = a.z - b.z
-      self
-    end
-
-    def multiply(v)
-      @x *= v.x
-      @y *= v.y
-      @z *= v.z
-      self
-    end
-
-    def multiply_scalar(scalar)
-      @x *= scalar
-      @y *= scalar
-      @z *= scalar
-      self
-    end
-
-    def multiply_vectors(a, b)
-      @x = a.x * b.x
-      @y = a.y * b.y
-      @z = a.z * b.z
-      self
-    end
+    def x=(value); @elements[0] = value.to_f; end
+    def y=(value); @elements[1] = value.to_f; end
+    def z=(value); @elements[2] = value.to_f; end
 
     def apply_euler(euler)
       quaternion = Mittsu::Quaternion.new
@@ -126,52 +35,46 @@ module Mittsu
     end
 
     def apply_matrix3(m)
-      x = @x
-      y = @y
-      z = @z
+      _x, _y, _z = *@elements
 
       e = m.elements
 
-      @x = e[0] * x + e[3] * y + e[6] * z
-      @y = e[1] * x + e[4] * y + e[7] * z
-      @z = e[2] * x + e[5] * y + e[8] * z
+      @elements[0] = e[0] * _x + e[3] * _y + e[6] * _z
+      @elements[1] = e[1] * _x + e[4] * _y + e[7] * _z
+      @elements[2] = e[2] * _x + e[5] * _y + e[8] * _z
 
       self
     end
 
     def apply_matrix4(m)
       # input: THREE.Matrix4 affine matrix
-
-      xx, yy, zz = @x, @y, @z
+      _x, _y, _z = *@elements
 
       e = m.elements
 
-      @x = e[0] * xx + e[4] * yy + e[8]  * zz + e[12]
-      @y = e[1] * xx + e[5] * yy + e[9]  * zz + e[13]
-      @z = e[2] * xx + e[6] * yy + e[10] * zz + e[14]
+      @elements[0] = e[0] * _x + e[4] * _y + e[8]  * _z + e[12]
+      @elements[1] = e[1] * _x + e[5] * _y + e[9]  * _z + e[13]
+      @elements[2] = e[2] * _x + e[6] * _y + e[10] * _z + e[14]
 
       self
     end
 
     def apply_projection(m)
       # input: THREE.Matrix4 projection matrix
-
-      _x, _y, _z = @x, @y, @z
+      _x, _y, _z = *@elements
 
       e = m.elements
       d = 1.0 / (e[3] * _x + e[7] * _y + e[11] * _z + e[15]) # perspective divide
 
-      @x = (e[0] * _x + e[4] * _y + e[8]  * _z + e[12]) * d
-      @y = (e[1] * _x + e[5] * _y + e[9]  * _z + e[13]) * d
-      @z = (e[2] * _x + e[6] * _y + e[10] * _z + e[14]) * d
+      @elements[0] = (e[0] * _x + e[4] * _y + e[8]  * _z + e[12]) * d
+      @elements[1] = (e[1] * _x + e[5] * _y + e[9]  * _z + e[13]) * d
+      @elements[2] = (e[2] * _x + e[6] * _y + e[10] * _z + e[14]) * d
 
       self
     end
 
     def apply_quaternion(q)
-      x = @x
-      y = @y
-      z = @z
+      _x, _y, _z = *@elements
 
       qx = q.x
       qy = q.y
@@ -179,17 +82,15 @@ module Mittsu
       qw = q.w
 
       # calculate quat * vector
-
-      ix =  qw * x + qy * z - qz * y
-      iy =  qw * y + qz * x - qx * z
-      iz =  qw * z + qx * y - qy * x
-      iw = - qx * x - qy * y - qz * z
+      ix =  qw * _x + qy * _z - qz * _y
+      iy =  qw * _y + qz * _x - qx * _z
+      iz =  qw * _z + qx * _y - qy * _x
+      iw = -qx * _x - qy * _y - qz * _z
 
       # calculate result * inverse quat
-
-      @x = ix * qw + iw * - qx + iy * - qz - iz * - qy
-      @y = iy * qw + iw * - qy + iz * - qx - ix * - qz
-      @z = iz * qw + iw * - qz + ix * - qy - iy * - qx
+      @elements[0] = ix * qw + iw * - qx + iy * - qz - iz * - qy
+      @elements[1] = iy * qw + iw * - qy + iz * - qx - ix * - qz
+      @elements[2] = iz * qw + iw * - qz + ix * - qy - iy * - qx
 
       self
     end
@@ -209,161 +110,32 @@ module Mittsu
     def transform_direction(m)
       # input: THREE.Matrix4 affine matrix
       # vector interpreted as a direction
-
-      x = @x, y = @y, z = @z
+      _x, _y, _z = *@elements
 
       e = m.elements
 
-      @x = e[0] * x + e[4] * y + e[8]  * z
-      @y = e[1] * x + e[5] * y + e[9]  * z
-      @z = e[2] * x + e[6] * y + e[10] * z
+      @elements[0] = e[0] * _x + e[4] * _y + e[8]  * _z
+      @elements[1] = e[1] * _x + e[5] * _y + e[9]  * _z
+      @elements[2] = e[2] * _x + e[6] * _y + e[10] * _z
 
       self.normalize
 
       self
     end
 
-    def divide(v)
-      @x /= v.x
-      @y /= v.y
-      @z /= v.z
-      self
-    end
-
-    def divide_scalar(scalar)
-      if scalar != 0
-        invScalar = 1.0 / scalar
-        @x *= invScalar
-        @y *= invScalar
-        @z *= invScalar
-      else
-        @x = 0
-        @y = 0
-        @z = 0
-      end
-      self
-    end
-
-    def min(v)
-      if @x > v.x
-        @x = v.x
-      end
-      if @y > v.y
-        @y = v.y
-      end
-      if @z > v.z
-        @z = v.z
-      end
-      self
-    end
-
-    def max(v)
-      if @x < v.x
-        @x = v.x
-      end
-      if @y < v.y
-        @y = v.y
-      end
-      if @z < v.z
-        @z = v.z
-      end
-      self
-    end
-
-    def clamp(min, max)
-      @x = Math.clamp(@x, min.x, max.x)
-      @y = Math.clamp(@y, min.y, max.y)
-      @z = Math.clamp(@z, min.z, max.z)
-      self
-    end
-
-    def clamp_scalar(min, max)
-      @x = Math.clamp(@x, min, max)
-      @y = Math.clamp(@y, min, max)
-      @z = Math.clamp(@z, min, max)
-      self
-    end
-
-    def floor
-      @x = @x.floor.to_f
-      @y = @y.floor.to_f
-      @z = @z.floor.to_f
-      self
-    end
-
-    def ceil
-      @x = @x.ceil.to_f
-      @y = @y.ceil.to_f
-      @z = @z.ceil.to_f
-      self
-    end
-
-    def round
-      @x = @x.round.to_f
-      @y = @y.round.to_f
-      @z = @z.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
-      @z = (@z < 0) ? @z.ceil.to_f : @z.floor.to_f
-      self
-    end
-
-    def negate
-      @x = - @x
-      @y = - @y
-      @z = - @z
-      self
-    end
-
     def dot(v)
-      @x * v.x + @y * v.y + @z * v.z
-    end
-
-    def length_sq
-      self.dot(self)
-    end
-
-    def length
-      Math.sqrt(length_sq)
+      x * v.x + y * v.y + z * v.z
     end
 
     def length_manhattan
-      @x.abs + @y.abs + @z.abs
-    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)
-      @x += (v.x - @x) * alpha
-      @y += (v.y - @y) * alpha
-      @z += (v.z - @z) * alpha
-      self
-    end
-
-    def lerp_vectors(v1, v2, alpha)
-      self.sub_vectors(v2, v1).multiply_scalar(alpha).add(v1)
-      self
+      x.abs + y.abs + z.abs
     end
 
     def cross(v)
-      x, y, z = @x, @y, @z
-      @x = y * v.z - z * v.y
-      @y = z * v.x - x * v.z
-      @z = x * v.y - y * v.x
+      _x, _y, _z = *@elements
+      @elements[0] = _y * v.z - _z * v.y
+      @elements[1] = _z * v.x - _x * v.z
+      @elements[2] = _x * v.y - _y * v.x
       self
     end
 
@@ -371,55 +143,24 @@ module Mittsu
       ax, ay, az = a.x, a.y, a.z
       bx, by, bz = b.x, b.y, b.z
 
-      @x = ay * bz - az * by
-      @y = az * bx - ax * bz
-      @z = ax * by - ay * bx
+      @elements[0] = ay * bz - az * by
+      @elements[1] = az * bx - ax * bz
+      @elements[2] = ax * by - ay * bx
 
       self
     end
 
-    def project_on_vector(vector)
-      v1 = Mittsu::Vector3.new
-      v1.copy(vector).normalize
-      dot = self.dot(v1)
-      self.copy(v1).multiply_scalar(dot)
-    end
-
-    def project_on_plane(plane_normal)
-      v1 = Mittsu::Vector3.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 = Mittsu::Vector3.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 distance_to_squared(v)
-      dx = @x - v.x
-      dy = @y - v.y
-      dz = @z - v.z
+      dx = x - v.x
+      dy = y - v.y
+      dz = z - v.z
       dx * dx + dy * dy + dz * dz
     end
 
     def set_from_matrix_position(m)
-      @x = m.elements[12]
-      @y = m.elements[13]
-      @z = m.elements[14]
+      @elements[0] = m.elements[12]
+      @elements[1] = m.elements[13]
+      @elements[2] = m.elements[14]
       self
     end
 
@@ -428,9 +169,9 @@ module Mittsu
       sy = self.set(m.elements[4], m.elements[5], m.elements[ 6]).length
       sz = self.set(m.elements[8], m.elements[9], m.elements[10]).length
 
-      @x = sx
-      @y = sy
-      @z = sz
+      @elements[0] = sx
+      @elements[1] = sy
+      @elements[2] = sz
 
       self
     end
@@ -440,52 +181,21 @@ module Mittsu
 
       me = matrix.elements
 
-      @x = me[offset]
-      @y = me[offset + 1]
-      @z = me[offset + 2]
+      @elements[0] = me[offset]
+      @elements[1] = me[offset + 1]
+      @elements[2] = me[offset + 2]
 
       self
     end
 
-    def ==(v)
-      ((v.x == @x) && (v.y == @y) && (v.z == @z))
-    end
-
-    def fromArray(array, offset = 0)
-      @x = array[offset]
-      @y = array[offset + 1]
-      @z = array[offset + 2]
-      self
-    end
-
-    def to_array(array = [], offset = 0)
-      array[offset] = @x
-      array[offset + 1] = @y
-      array[offset + 2] = @z
-
-      array
-    end
-
-    def to_a
-      self.to_array
-    end
-
-    def from_attribute(attribute, index, offse = 0)
+    def from_attribute(attribute, index, offset = 0)
       index = index * attribute.itemSize + offset
 
-      @x = attribute.array[index]
-      @y = attribute.array[index + 1]
-      @z = attribute.array[index + 2]
+      @elements[0] = attribute.array[index]
+      @elements[1] = attribute.array[index + 1]
+      @elements[2] = attribute.array[index + 2]
 
       self
     end
-
-    def clone
-      Mittsu::Vector3.new(@x, @y, @z)
-    end
-
-    def to_s
-      "[#{x}, #{y}, #{z}]"
-    end
   end
 end