mittsu 0.1.0

data/lib/mittsu/math/color_keywords.rb

@@ -0,0 +1,151 @@
+module Mittsu
+  ColorKeywords = {
+    'aliceblue' => 0xF0F8FF,
+    'antiquewhite' => 0xFAEBD7,
+    'aqua' => 0x00FFFF,
+    'aquamarine' => 0x7FFFD4,
+    'azure' => 0xF0FFFF,
+    'beige' => 0xF5F5DC,
+    'bisque' => 0xFFE4C4,
+    'black' => 0x000000,
+    'blanchedalmond' => 0xFFEBCD,
+    'blue' => 0x0000FF,
+    'blueviolet' => 0x8A2BE2,
+    'brown' => 0xA52A2A,
+    'burlywood' => 0xDEB887,
+    'cadetblue' => 0x5F9EA0,
+    'chartreuse' => 0x7FFF00,
+    'chocolate' => 0xD2691E,
+    'coral' => 0xFF7F50,
+    'cornflowerblue' => 0x6495ED,
+    'cornsilk' => 0xFFF8DC,
+    'crimson' => 0xDC143C,
+    'cyan' => 0x00FFFF,
+    'darkblue' => 0x00008B,
+    'darkcyan' => 0x008B8B,
+    'darkgoldenrod' => 0xB8860B,
+    'darkgray' => 0xA9A9A9,
+    'darkgreen' => 0x006400,
+    'darkgrey' => 0xA9A9A9,
+    'darkkhaki' => 0xBDB76B,
+    'darkmagenta' => 0x8B008B,
+    'darkolivegreen' => 0x556B2F,
+    'darkorange' => 0xFF8C00,
+    'darkorchid' => 0x9932CC,
+    'darkred' => 0x8B0000,
+    'darksalmon' => 0xE9967A,
+    'darkseagreen' => 0x8FBC8F,
+    'darkslateblue' => 0x483D8B,
+    'darkslategray' => 0x2F4F4F,
+    'darkslategrey' => 0x2F4F4F,
+    'darkturquoise' => 0x00CED1,
+    'darkviolet' => 0x9400D3,
+    'deeppink' => 0xFF1493,
+    'deepskyblue' => 0x00BFFF,
+    'dimgray' => 0x696969,
+    'dimgrey' => 0x696969,
+    'dodgerblue' => 0x1E90FF,
+    'firebrick' => 0xB22222,
+    'floralwhite' => 0xFFFAF0,
+    'forestgreen' => 0x228B22,
+    'fuchsia' => 0xFF00FF,
+    'gainsboro' => 0xDCDCDC,
+    'ghostwhite' => 0xF8F8FF,
+    'gold' => 0xFFD700,
+    'goldenrod' => 0xDAA520,
+    'gray' => 0x808080,
+    'green' => 0x008000,
+    'greenyellow' => 0xADFF2F,
+    'grey' => 0x808080,
+    'honeydew' => 0xF0FFF0,
+    'hotpink' => 0xFF69B4,
+    'indianred' => 0xCD5C5C,
+    'indigo' => 0x4B0082,
+    'ivory' => 0xFFFFF0,
+    'khaki' => 0xF0E68C,
+    'lavender' => 0xE6E6FA,
+    'lavenderblush' => 0xFFF0F5,
+    'lawngreen' => 0x7CFC00,
+    'lemonchiffon' => 0xFFFACD,
+    'lightblue' => 0xADD8E6,
+    'lightcoral' => 0xF08080,
+    'lightcyan' => 0xE0FFFF,
+    'lightgoldenrodyellow' => 0xFAFAD2,
+    'lightgray' => 0xD3D3D3,
+    'lightgreen' => 0x90EE90,
+    'lightgrey' => 0xD3D3D3,
+    'lightpink' => 0xFFB6C1,
+    'lightsalmon' => 0xFFA07A,
+    'lightseagreen' => 0x20B2AA,
+    'lightskyblue' => 0x87CEFA,
+    'lightslategray' => 0x778899,
+    'lightslategrey' => 0x778899,
+    'lightsteelblue' => 0xB0C4DE,
+    'lightyellow' => 0xFFFFE0,
+    'lime' => 0x00FF00,
+    'limegreen' => 0x32CD32,
+    'linen' => 0xFAF0E6,
+    'magenta' => 0xFF00FF,
+    'maroon' => 0x800000,
+    'mediumaquamarine' => 0x66CDAA,
+    'mediumblue' => 0x0000CD,
+    'mediumorchid' => 0xBA55D3,
+    'mediumpurple' => 0x9370DB,
+    'mediumseagreen' => 0x3CB371,
+    'mediumslateblue' => 0x7B68EE,
+    'mediumspringgreen' => 0x00FA9A,
+    'mediumturquoise' => 0x48D1CC,
+    'mediumvioletred' => 0xC71585,
+    'midnightblue' => 0x191970,
+    'mintcream' => 0xF5FFFA,
+    'mistyrose' => 0xFFE4E1,
+    'moccasin' => 0xFFE4B5,
+    'navajowhite' => 0xFFDEAD,
+    'navy' => 0x000080,
+    'oldlace' => 0xFDF5E6,
+    'olive' => 0x808000,
+    'olivedrab' => 0x6B8E23,
+    'orange' => 0xFFA500,
+    'orangered' => 0xFF4500,
+    'orchid' => 0xDA70D6,
+    'palegoldenrod' => 0xEEE8AA,
+    'palegreen' => 0x98FB98,
+    'paleturquoise' => 0xAFEEEE,
+    'palevioletred' => 0xDB7093,
+    'papayawhip' => 0xFFEFD5,
+    'peachpuff' => 0xFFDAB9,
+    'peru' => 0xCD853F,
+    'pink' => 0xFFC0CB,
+    'plum' => 0xDDA0DD,
+    'powderblue' => 0xB0E0E6,
+    'purple' => 0x800080,
+    'red' => 0xFF0000,
+    'rosybrown' => 0xBC8F8F,
+    'royalblue' => 0x4169E1,
+    'saddlebrown' => 0x8B4513,
+    'salmon' => 0xFA8072,
+    'sandybrown' => 0xF4A460,
+    'seagreen' => 0x2E8B57,
+    'seashell' => 0xFFF5EE,
+    'sienna' => 0xA0522D,
+    'silver' => 0xC0C0C0,
+    'skyblue' => 0x87CEEB,
+    'slateblue' => 0x6A5ACD,
+    'slategray' => 0x708090,
+    'slategrey' => 0x708090,
+    'snow' => 0xFFFAFA,
+    'springgreen' => 0x00FF7F,
+    'steelblue' => 0x4682B4,
+    'tan' => 0xD2B48C,
+    'teal' => 0x008080,
+    'thistle' => 0xD8BFD8,
+    'tomato' => 0xFF6347,
+    'turquoise' => 0x40E0D0,
+    'violet' => 0xEE82EE,
+    'wheat' => 0xF5DEB3,
+    'white' => 0xFFFFFF,
+    'whitesmoke' => 0xF5F5F5,
+    'yellow' => 0xFFFF00,
+    'yellowgreen' => 0x9ACD32
+  }
+end

data/lib/mittsu/math/euler.rb

@@ -0,0 +1,182 @@
+require 'mittsu/math'
+
+module Mittsu
+  class Euler
+    RotationOrders = [ 'XYZ', 'YZX', 'ZXY', 'XZY', 'YXZ', 'ZYX' ]
+    DefaultOrder = 'XYZ'
+
+    attr_reader :x, :y, :z, :order
+
+    def initialize(x = 0.0, y = 0.0, z = 0.0, order = DefaultOrder)
+      @x, @y, @z, @order = x.to_f, y.to_f, z.to_f, order
+    end
+
+    def set(x, y, z, order)
+      @x = x.to_f
+      @y = y.to_f
+      @z = z.to_f
+      @order = order || @order
+      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 order=(order)
+      @order = order
+      self.on_change_callback
+    end
+
+    def copy(euler)
+      @x = euler.x
+      @y = euler.y
+      @z = euler.z
+      @order = euler.order
+      self.on_change_callback
+      self
+    end
+
+    def set_from_rotation_matrix(m, order, update = true)
+      # 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]
+      order = order || @order
+      if order == 'XYZ'
+        @y = Math.asin(Math.clamp(m13, -1.0, 1.0))
+        if m13.abs < 0.99999
+          @x = Math.atan2(- m23, m33)
+          @z = Math.atan2(- m12, m11)
+        else
+          @x = Math.atan2(m32, m22)
+          @z = 0.0
+        end
+      elsif order == 'YXZ'
+        @x = Math.asin(- Math.clamp(m23, -1.0, 1.0))
+        if m23.abs < 0.99999
+          @y = Math.atan2(m13, m33)
+          @z = Math.atan2(m21, m22)
+        else
+          @y = Math.atan2(- m31, m11)
+          @z = 0.0
+        end
+      elsif order == 'ZXY'
+        @x = Math.asin(Math.clamp(m32, -1.0, 1.0))
+        if m32.abs < 0.99999
+          @y = Math.atan2(- m31, m33)
+          @z = Math.atan2(- m12, m22)
+        else
+          @y = 0.0
+          @z = Math.atan2(m21, m11)
+        end
+      elsif order == 'ZYX'
+        @y = Math.asin(- Math.clamp(m31, -1.0, 1.0))
+        if m31.abs < 0.99999
+          @x = Math.atan2(m32, m33)
+          @z = Math.atan2(m21, m11)
+        else
+          @x = 0.0
+          @z = Math.atan2(- m12, m22)
+        end
+      elsif order == 'YZX'
+        @z = Math.asin(Math.clamp(m21, -1.0, 1.0))
+        if m21.abs < 0.99999
+          @x = Math.atan2(- m23, m22)
+          @y = Math.atan2(- m31, m11)
+        else
+          @x = 0.0
+          @y = Math.atan2(m13, m33)
+        end
+      elsif order == 'XZY'
+        @z = Math.asin(- Math.clamp(m12, -1.0, 1.0))
+        if m12.abs < 0.99999
+          @x = Math.atan2(m32, m22)
+          @y = Math.atan2(m13, m11)
+        else
+          @x = Math.atan2(- m23, m33)
+          @y = 0.0
+        end
+      else
+        puts("WARNING: Mittsu::Euler#set_from_rotation_matrix given unsupported order: #{order}")
+      end
+      @order = order
+      self.on_change_callback if update
+      self
+    end
+
+    def set_from_quaternion(q, order, update = true)
+      matrix = Mittsu::Matrix4.new
+      matrix.make_rotation_from_quaternion(q)
+      self.set_from_rotation_matrix(matrix, order, update)
+      self
+    end
+
+    def set_from_vector3(v, order)
+      self.set(v.x, v.y, v.z, order || @order)
+    end
+
+    def reorder(new_order)
+      # WARNING: this discards revolution information -bhouston
+      q = Mittsu::Quaternion.new.set_from_euler(self)
+      self.set_from_quaternion(q, new_order)
+    end
+
+    def ==(euler)
+      (euler.x == @x) && (euler.y == @y) && (euler.z == @z) && (euler.order == @order)
+    end
+
+    def from_array(array)
+      @x = array[0]
+      @y = array[1]
+      @z = array[2]
+      @order = array[3] unless array[3].nil?
+      self.on_change_callback
+      self
+    end
+
+    def to_a(array = [], offset = 0)
+      array[offset] = @x
+      array[offset + 1] = @y
+      array[offset + 2] = @z
+      array[offset + 3] = @order
+      array
+    end
+
+    def to_vector3(optional_result = nil)
+      if optional_result
+        return optional_result.set(@x, @y, @z)
+      else
+        return Mittsu::Vector3.new(@x, @y, @z)
+      end
+    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::Euler.new(@x, @y, @z, @order)
+    end
+
+  end
+end

data/lib/mittsu/math/frustum.rb

@@ -0,0 +1,106 @@
+require 'mittsu/math'
+
+module Mittsu
+  class Frustum
+    attr_accessor :planes
+
+    def initialize(p0 = nil, p1 = nil, p2 = nil, p3 = nil, p4 = nil, p5 = nil)
+      @planes = [
+        p0 || Mittsu::Plane.new,
+        p1 || Mittsu::Plane.new,
+        p2 || Mittsu::Plane.new,
+        p3 || Mittsu::Plane.new,
+        p4 || Mittsu::Plane.new,
+        p5 || Mittsu::Plane.new
+      ]
+    end
+
+    def set(p0, p1, p2, p3, p4, p5)
+      planes = self.planes
+      planes[0].copy(p0)
+      planes[1].copy(p1)
+      planes[2].copy(p2)
+      planes[3].copy(p3)
+      planes[4].copy(p4)
+      planes[5].copy(p5)
+      self
+    end
+
+    def copy(frustum)
+      planes = self.planes
+      6.times do |i|
+        planes[i].copy(frustum.planes[i])
+      end
+      self
+    end
+
+    def set_from_matrix(m)
+      planes = self.planes
+      me = m.elements
+      me0 = me[0]; me1 = me[1]; me2 = me[2]; me3 = me[3]
+      me4 = me[4]; me5 = me[5]; me6 = me[6]; me7 = me[7]
+      me8 = me[8]; me9 = me[9]; me10 = me[10]; me11 = me[11]
+      me12 = me[12]; me13 = me[13]; me14 = me[14]; me15 = me[15]
+      planes[0].set_components(me3 - me0, me7 - me4, me11 - me8, me15 - me12).normalize
+      planes[1].set_components(me3 + me0, me7 + me4, me11 + me8, me15 + me12).normalize
+      planes[2].set_components(me3 + me1, me7 + me5, me11 + me9, me15 + me13).normalize
+      planes[3].set_components(me3 - me1, me7 - me5, me11 - me9, me15 - me13).normalize
+      planes[4].set_components(me3 - me2, me7 - me6, me11 - me10, me15 - me14).normalize
+      planes[5].set_components(me3 + me2, me7 + me6, me11 + me10, me15 + me14).normalize
+      self
+    end
+
+    def intersects_object?(object)
+      sphere = Mittsu::Sphere.new
+      geometry = object.geometry
+      geometry.compute_bounding_sphere if geometry.bounding_sphere.nil?
+      sphere.copy(geometry.bounding_sphere)
+      sphere.apply_matrix4(object.matrix_world)
+      self.intersects_sphere?(sphere)
+    end
+
+    def intersects_sphere?(sphere)
+      planes = self.planes
+      center = sphere.center
+      negRadius = -sphere.radius
+      6.times do |i|
+        distance = planes[i].distance_to_point(center)
+        return false if distance < negRadius
+      end
+      true
+    end
+
+    def intersects_box?(box)
+      p1 = Mittsu::Vector3.new
+      p2 = Mittsu::Vector3.new
+      planes = self.planes
+      6.times do |i|
+        plane = planes[i]
+        p1.x = plane.normal.x > 0 ? box.min.x : box.max.x
+        p2.x = plane.normal.x > 0 ? box.max.x : box.min.x
+        p1.y = plane.normal.y > 0 ? box.min.y : box.max.y
+        p2.y = plane.normal.y > 0 ? box.max.y : box.min.y
+        p1.z = plane.normal.z > 0 ? box.min.z : box.max.z
+        p2.z = plane.normal.z > 0 ? box.max.z : box.min.z
+        d1 = plane.distance_to_point(p1)
+        d2 = plane.distance_to_point(p2)
+        # if both outside plane, no intersection
+        return false if d1 < 0 && d2 < 0
+      end
+      true
+    end
+
+    def contains_point?(point)
+      planes = self.planes
+      6.times do |i|
+        return false if planes[i].distance_to_point(point) < 0
+      end
+      true
+    end
+
+    def clone
+      Mittsu::Frustum.new.copy(self)
+    end
+
+  end
+end

data/lib/mittsu/math/line3.rb

@@ -0,0 +1,76 @@
+require 'mittsu/math'
+
+module Mittsu
+  class Line3
+    attr_accessor :start_point, :end_point
+
+    def initialize(start_point = Mittsu::Vector3.new, end_point = Mittsu::Vector3.new)
+      @start_point, @end_point = start_point, end_point
+    end
+
+    def set(start_point, end_point)
+      @start_point.copy(start_point)
+      @end_point.copy(end_point)
+      self
+    end
+
+    def copy(line)
+      @start_point.copy(line.start_point)
+      @end_point.copy(line.end_point)
+      self
+    end
+
+    def center(target = Mittsu::Vector3.new)
+      target.add_vectors(@start_point, @end_point).multiply_scalar(0.5)
+    end
+
+    def delta(target = Mittsu::Vector3.new)
+      target.sub_vectors(@end_point, @start_point)
+    end
+
+    def distance_sq
+      @start_point.distance_to_squared(@end_point)
+    end
+
+    def distance
+      @start_point.distance_to(@end_point)
+    end
+
+    def at(t, target = Mittsu::Vector3.new)
+      self.delta(target).multiply_scalar(t).add(self.start_point)
+    end
+
+    def closest_point_to_point_parameter(point, clamp_to_line)
+      start_p = Mittsu::Vector3.new
+      start_end = Mittsu::Vector3.new
+      start_p.sub_vectors(point, @start_point)
+      start_end.sub_vectors(@end_point, @start_point)
+      start_end2 = start_end.dot(start_end)
+      start_end_start_p = start_end.dot(start_p)
+      t = start_end_start_p / start_end2
+      if clamp_to_line
+        t = Math.clamp(t, 0.0, 1.0)
+      end
+      t
+    end
+
+    def closest_point_to_point(point, clamp_to_line, target = Mittsu::Vector3.new)
+      t = self.closest_point_to_point_parameter(point, clamp_to_line)
+      self.delta(target).multiply_scalar(t).add(self.start_point)
+    end
+
+    def apply_matrix4(matrix)
+      @start_point.apply_matrix4(matrix)
+      @end_point.apply_matrix4(matrix)
+      self
+    end
+
+    def equals(line)
+      line.start_point.equals(@start_point) && line.end_point.equals(@end_point)
+    end
+
+    def clone
+      Mittsu::Line3.new.copy(self)
+    end
+  end
+end