mittsu 0.1.1 → 0.1.2

data/lib/mittsu/math/vector4.rb

@@ -1,140 +1,48 @@
 require 'mittsu/math'
+require 'mittsu/math/vector'
 
 module Mittsu
-  class Vector4
-    attr_accessor :x, :y, :z, :w
-    def initialize(x = 0.0, y = 0.0, z = 0.0, w = 1.0)
-      self.set(x, y, z, w)
-    end
-
-    def set(x, y, z, w)
-      @x, @y, @z, @w = x.to_f, y.to_f, z.to_f, w.to_f
-      self
-    end
-
-    def set_x(x)
-      @x = x.to_f
-      self
-    end
-
-    def set_y(y)
-      @y = y.to_f
-      self
-    end
-
-    def set_z(z)
-      @z = z.to_f
-      self
-    end
+  class Vector4 < Vector
+    ELEMENTS = { x: 0, y: 1, z: 2, w: 3 }
+    DIMENSIONS = ELEMENTS.count
 
-    def set_w(w)
-      @w = w.to_f
-      self
-    end
-
-    def set_component(index, value)
-      case index
-      when 0 then @x = value.to_f
-      when 1 then @y = value.to_f
-      when 2 then @z = value.to_f
-      when 3 then @w = value.to_f
-      else raise IndexError.new
-      end
-    end
-
-    def get_component(index)
-      case index
-      when 0 then return @x
-      when 1 then return @y
-      when 2 then return @z
-      when 3 then return @w
-      else raise IndexError.new
-      end
-    end
-
-    def copy(v)
-      @x = v.x
-      @y = v.y
-      @z = v.z
-      @w = v.w || 1.0
-      self
-    end
-
-    def add(v)
-      @x += v.x
-      @y += v.y
-      @z += v.z
-      @w += v.w
-      self
+    def initialize(x = 0, y = 0, z = 0, w = 1)
+      super [x.to_f, y.to_f, z.to_f, w.to_f]
     end
 
-    def add_scalar(s)
-      @x += s
-      @y += s
-      @z += s
-      @w += s
-      self
-    end
-
-    def add_vectors(a, b)
-      @x = a.x + b.x
-      @y = a.y + b.y
-      @z = a.z + b.z
-      @w = a.w + b.w
-      self
-    end
-
-    def sub(v)
-      @x -= v.x
-      @y -= v.y
-      @z -= v.z
-      @w -= v.w
-      self
-    end
-
-    def sub_scalar(s)
-      @x -= s
-      @y -= s
-      @z -= s
-      @w -= s
-      self
+    def set(x, y, z, w)
+      super [x.to_f, y.to_f, z.to_f, w.to_f]
     end
 
-    def sub_vectors(a, b)
-      @x = a.x - b.x
-      @y = a.y - b.y
-      @z = a.z - b.z
-      @w = a.w - b.w
-      self
-    end
+    def x; @elements[0]; end
+    def y; @elements[1]; end
+    def z; @elements[2]; end
+    def w; @elements[3]; end
 
-    def multiply_scalar(scalar)
-      @x *= scalar
-      @y *= scalar
-      @z *= scalar
-      @w *= scalar
-      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 w=(value); @elements[3] = value.to_f; end
 
     def apply_matrix4(m)
-      x1, y1, z1, w1 = @x, @y, @z, @w
+      _x, _y, _z, _w = *@elements
       e = m.elements
-      @x = e[0] * x1 + e[4] * y1 + e[8] * z1 + e[12] * w1
-      @y = e[1] * x1 + e[5] * y1 + e[9] * z1 + e[13] * w1
-      @z = e[2] * x1 + e[6] * y1 + e[10] * z1 + e[14] * w1
-      @w = e[3] * x1 + e[7] * y1 + e[11] * z1 + e[15] * w1
+      @elements[0] = e[0] * _x + e[4] * _y + e[8]  * _z + e[12] * _w
+      @elements[1] = e[1] * _x + e[5] * _y + e[9]  * _z + e[13] * _w
+      @elements[2] = e[2] * _x + e[6] * _y + e[10] * _z + e[14] * _w
+      @elements[3] = e[3] * _x + e[7] * _y + e[11] * _z + e[15] * _w
       self
     end
 
     def divide_scalar(scalar)
       if scalar != 0.0
         inv_scalar = 1.0 / scalar
-        @x *= inv_scalar
-        @y *= inv_scalar
-        @z *= inv_scalar
-        @w *= inv_scalar
+        @elements[0] *= inv_scalar
+        @elements[1] *= inv_scalar
+        @elements[2] *= inv_scalar
+        @elements[3] *= inv_scalar
       else
-        @x, @y, @z, @w = 0.0, 0.0, 0.0, 1.0
+        @elements = [0.0, 0.0, 0.0, 1.0]
       end
       self
     end
@@ -142,16 +50,16 @@ module Mittsu
     def set_axis_angle_from_quaternion(q)
       # http:#www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm
       # q is assumed to be normalized
-      @w = 2.0 * Math.acos(q.w)
+      @elements[3] = 2.0 * Math.acos(q.w)
       s = Math.sqrt(1.0 - q.w * q.w)
       if s < 0.0001
-         @x = 1.0
-         @y = 0.0
-         @z = 0.0
+         @elements[0] = 1.0
+         @elements[1] = 0.0
+         @elements[2] = 0.0
       else
-         @x = q.x / s
-         @y = q.y / s
-         @z = q.z / s
+         @elements[0] = q.x / s
+         @elements[1] = q.y / s
+         @elements[2] = q.z / s
       end
       self
     end
@@ -177,7 +85,7 @@ module Mittsu
             ((m23 + m32).abs < epsilon2) &&
             ((m11 + m22 + m33 - 3).abs < epsilon2))
           # self singularity is identity matrix so angle = 0
-          self.set(1, 0, 0, 0)
+          @elements = [1.0, 0.0, 0.0, 0.0]
           return self # zero angle, arbitrary axis
         end
         # otherwise self singularity is angle = 180
@@ -219,7 +127,7 @@ module Mittsu
             y1 = yz / z1
           end
         end
-        self.set(x1, y1, z1, angle)
+        @elements = [x1, y1, z1, angle]
         return self # return 180 deg rotation
       end
       # as we have reached here there are no singularities so we can handle normally
@@ -229,186 +137,28 @@ module Mittsu
       s = 1.0 if (s.abs < 0.001)
       # prevent divide by zero, should not happen if matrix is orthogonal and should be
       # caught by singularity test above, but I've left it in just in case
-      @x = (m32 - m23) / s
-      @y = (m13 - m31) / s
-      @z = (m21 - m12) / s
-      @w = Math.acos((m11 + m22 + m33 - 1.0) / 2.0)
-      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
-      if @w > v.w
-        @w = v.w
-      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
-      if @w < v.w
-        @w = v.w
-      end
-      self
-    end
-
-    def clamp(min, max)
-      # This function assumes min < max, if self assumption isn't true it will not operate correctly
-      if @x < min.x
-        @x = min.x
-      elsif @x > max.x
-        @x = max.x
-      end
-      if @y < min.y
-        @y = min.y
-      elsif @y > max.y
-        @y = max.y
-      end
-      if @z < min.z
-        @z = min.z
-      elsif @z > max.z
-        @z = max.z
-      end
-      if @w < min.w
-        @w = min.w
-      elsif @w > max.w
-        @w = max.w
-      end
-      self
-    end
-
-    def floor
-      @x = (@x).floor
-      @y = (@y).floor
-      @z = (@z).floor
-      @w = (@w).floor
-      self
-    end
-
-    def ceil
-      @x = (@x).ceil
-      @y = (@y).ceil
-      @z = (@z).ceil
-      @w = (@w).ceil
-      self
-    end
-
-    def round
-      @x = (@x).round
-      @y = (@y).round
-      @z = (@z).round
-      @w = (@w).round
-      self
-    end
-
-    def round_to_zero
-      @x = (@x < 0) ? (@x).ceil : (@x).floor
-      @y = (@y < 0) ? (@y).ceil : (@y).floor
-      @z = (@z < 0) ? (@z).ceil : (@z).floor
-      @w = (@w < 0) ? (@w).ceil : (@w).floor
-      self
-    end
-
-    def negate
-      @x = - @x
-      @y = - @y
-      @z = - @z
-      @w = - @w
+      @elements[0] = (m32 - m23) / s
+      @elements[1] = (m13 - m31) / s
+      @elements[2] = (m21 - m12) / s
+      @elements[3] = Math.acos((m11 + m22 + m33 - 1.0) / 2.0)
       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)
+      x * v.x + y * v.y + z * v.z + w * v.w
     end
 
     def length_manhattan
-      (@x).abs + (@y).abs + (@z).abs + (@w).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
-      @w += (v.w - @w) * alpha
-      self
-    end
-
-    def lerp_vectors(v1, v2, alpha)
-      self.sub_vectors(v2, v1).multiply_scalar(alpha).add(v1)
-      self
-    end
-
-    def ==(v)
-      ((v.x == @x) && (v.y == @y) && (v.z == @z) && (v.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
-    end
-
-    def to_array(array = [], offset = 0)
-      array[offset] = @x
-      array[offset + 1] = @y
-      array[offset + 2] = @z
-      array[offset + 3] = @w
-      array
+      x.abs + y.abs + z.abs + w.abs
     end
 
     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]
-      @w = attribute.array[index + 3]
+      @elements[0] = attribute.array[index]
+      @elements[1] = attribute.array[index + 1]
+      @elements[2] = attribute.array[index + 2]
+      @elements[3] = attribute.array[index + 3]
       self
     end
-
-    def clone
-      Mittsu::Vector4.new @x, @y, @z, @w
-    end
-
-    def to_s
-      "[#{x}, #{y}, #{z}, #{w}]"
-    end
   end
 end

data/lib/mittsu/objects/line.rb

@@ -1,6 +1,6 @@
 module Mittsu
   class Line < Object3D
-    attr_accessor :geometry, :material, :mode, :type
+    attr_accessor :geometry, :material, :mode, :type, :morph_target_base
 
     def initialize(geometry = nil, material = nil, mode = nil)
       super()
@@ -8,7 +8,7 @@ module Mittsu
       @type = 'Line'
 
       @geometry = geometry || Geometry.new
-      @material = material || LineBasicMaterial.new(color: rand * 0xffffff)
+      @material = material || LineBasicMaterial.new(color: (rand * 0xffffff).to_i)
 
       @mode = mode || LineStrip
 
@@ -139,5 +139,15 @@ module Mittsu
       super(object)
       object
     end
+
+    protected
+
+    def jsonify
+      data = super
+      data[:geometry] = jsonify_geometry(self.geometry)
+      data[:material] = jsonify_material(self.material)
+      data[:mode] = self.mode
+      data
+    end
   end
 end

data/lib/mittsu/objects/mesh.rb

@@ -5,7 +5,7 @@ module Mittsu
   class Mesh < Object3D
     attr_accessor :material, :morph_target_base
 
-    def initialize(geometry = Geometry.new, material = MeshBasicMaterial.new(color: rand * 0xffffff))
+    def initialize(geometry = Geometry.new, material = MeshBasicMaterial.new(color: (rand * 0xffffff).to_i))
       super()
 
       @type = 'Mesh'
@@ -16,7 +16,7 @@ module Mittsu
     end
 
     def update_morph_targets
-      if !@morph_targets.nil? && !@morph_targets.empty?
+      if !@geometry.morph_targets.nil? && !@geometry.morph_targets.empty?
         @morph_targets_base = -1
         @morph_target_forced_order = []
         @morph_targets_influences = []
@@ -38,13 +38,13 @@ module Mittsu
     end
 
     def raycast(raycaster, intersects)
-      @_inverse_matrix = Matrix4.new
-      @_ray = Ray.new
-      @_sphere = Sphere.new
+      @_inverse_matrix ||= Matrix4.new
+      @_ray ||= Ray.new
+      @_sphere ||= Sphere.new
 
-      @_v_a = Vector3.new
-      @_v_b = Vector3.new
-      @_v_c = Vector3.new
+      @_v_a ||= Vector3.new
+      @_v_b ||= Vector3.new
+      @_v_c ||= Vector3.new
 
       # Checking bounding_sphere distance to ray
 
@@ -60,7 +60,7 @@ module Mittsu
       inverse_matrix.inverse(@matrix_world)
       ray.copy(raycaster.ray).apply_matrix4(inverse_matrix)
 
-      if !geometry.bounding_bounding_box
+      if !geometry.bounding_bounding_box.nil?
         return unless ray.intersection_box?(geometry.bounding_box)
       end
 
@@ -239,5 +239,14 @@ module Mittsu
       super(object, recursive)
       return object
     end
+
+    protected
+
+    def jsonify
+      data = super
+      data[:geometry] = jsonify_geometry(@geometry)
+      data[:material] = jsonify_material(@material)
+      data
+    end
   end
 end