mittsu 0.1.0

data/lib/mittsu/math/box2.rb

@@ -0,0 +1,135 @@
+require 'mittsu/math'
+
+module Mittsu
+  class Box2
+    attr_accessor :min, :max
+
+    def initialize(min = nil, max = nil)
+      @min = min || Mittsu::Vector2.new(Float::INFINITY, Float::INFINITY)
+      @max = max || Mittsu::Vector2.new(-Float::INFINITY, -Float::INFINITY)
+    end
+
+    def set(min, max)
+      @min.copy(min)
+      @max.copy(max)
+      self
+    end
+
+    def set_from_points(points)
+      self.make_empty
+      points.each do |point|
+        self.expand_by_point(point)
+      end
+      self
+    end
+
+    def set_from_center_and_size(center, size)
+      halfSize = size.clone.multiply_scalar(0.5)
+      @min.copy(center).sub(halfSize)
+      @max.copy(center).add(halfSize)
+      self
+    end
+
+    def copy(box)
+      @min.copy(box.min)
+      @max.copy(box.max)
+      self
+    end
+
+    def make_empty
+      @min.x = @min.y = Float::INFINITY
+      @max.x = @max.y = - Float::INFINITY
+      self
+    end
+
+    def empty?
+      # this is a more robust check for empty than (volume <= 0) because volume can get positive with two negative axes
+      (@max.x < @min.x) || (@max.y < @min.y)
+    end
+
+    def center(target = Mittsu::Vector2.new)
+      target.add_vectors(@min, @max).multiply_scalar(0.5)
+    end
+
+    def size(target = Mittsu::Vector2.new)
+      target.sub_vectors(@max, @min)
+    end
+
+    def expand_by_point(point)
+      @min.min(point)
+      @max.max(point)
+      self
+    end
+
+    def expand_by_vector(vector)
+      @min.sub(vector)
+      @max.add(vector)
+      self
+    end
+
+    def expand_by_scalar(scalar)
+      @min.add_scalar(-scalar)
+      @max.add_scalar(scalar)
+      self
+    end
+
+    def contains_point?(point)
+      !(point.x < @min.x || point.x > @max.x || point.y < @min.y || point.y > @max.y)
+    end
+
+    def contains_box?(box)
+      ((@min.x <= box.min.x) && (box.max.x <= @max.x) && (@min.y <= box.min.y) && (box.max.y <= @max.y))
+    end
+
+    def parameter(point, target = Mittsu::Vector2.new)
+      # This can potentially have a divide by zero if the box
+      # has a size dimension of 0.
+      target.set(
+        (point.x - @min.x) / (@max.x - @min.x),
+        (point.y - @min.y) / (@max.y - @min.y)
+      )
+    end
+
+    def intersection_box?(box)
+      # using 6 splitting planes to rule out intersections.
+      !(box.max.x < @min.x || box.min.x > @max.x || box.max.y < @min.y || box.min.y > @max.y)
+    end
+
+    def clamp_point(point, target = nil)
+      result = target || Mittsu::Vector2.new
+      result.copy(point).clamp(@min, @max)
+    end
+
+    def distance_to_point(point)
+      clampedPoint = point.clone.clamp(@min, @max)
+      clampedPoint.sub(point).length
+    end
+
+    def intersect(box)
+      @min.max(box.min)
+      @max.min(box.max)
+      self
+    end
+
+    def union(box)
+      @min.min(box.min)
+      @max.max(box.max)
+      self
+    end
+
+    def translate(offset)
+      @min.add(offset)
+      @max.add(offset)
+      self
+    end
+
+    def ==(box)
+      box.min == @min && box.max == @max
+    end
+
+    def clone
+      Mittsu::Box2.new.copy(self)
+    end
+
+  end
+end

data/lib/mittsu/math/box3.rb

@@ -0,0 +1,194 @@
+require 'mittsu/math'
+
+module Mittsu
+  class Box3
+    attr_accessor :min, :max
+
+    def initialize(min = nil, max = nil)
+      @min = min || Mittsu::Vector3.new(Float::INFINITY, Float::INFINITY, Float::INFINITY)
+      @max = max || Mittsu::Vector3.new(-Float::INFINITY, -Float::INFINITY, -Float::INFINITY)
+    end
+
+    def set(min, max)
+      @min.copy(min)
+      @max.copy(max)
+      self
+    end
+
+    def set_from_points(points)
+      self.make_empty
+      points.each do |point|
+        self.expand_by_point(point)
+      end
+      self
+    end
+
+    def set_from_center_and_size(center, size)
+      halfSize = size.clone.multiply_scalar(0.5)
+      @min.copy(center).sub(halfSize)
+      @max.copy(center).add(halfSize)
+      self
+    end
+
+    def set_from_object(object)
+      # Computes the world-axis-aligned bounding box of an object (including its children),
+      # accounting for both the object's, and childrens', world transforms
+      v1 = Mittsu::Vector3.new
+      scope = self
+      object.update_matrix_world(true)
+      self.make_empty
+      object.traverse do |node|
+        geometry = node.geometry
+        if geometry != nil
+          if geometry instanceof Mittsu::Geometry
+            vertices = geometry.vertices
+            vertices.each do |vertex|
+              v1.copy(vertex)
+              v1.apply_matrix4(node.matrixWorld)
+              scope.expand_by_point(v1)
+            end
+          elsif geometry instanceof Mittsu::BufferGeometry && geometry.attributes['position'] != nil
+            positions = geometry.attributes['position'].array
+            positions.each_slice(3) do |postition|
+              v1.set(position[0], position[1], position[2])
+              v1.apply_matrix4(node.matrixWorld)
+              scope.expand_by_point(v1)
+            end
+          end
+        end
+      end
+      return self
+    end
+
+    def copy(box)
+      @min.copy(box.min)
+      @max.copy(box.max)
+      self
+    end
+
+    def make_empty
+      @min.x = @min.y = @min.z = Float::INFINITY
+      @max.x = @max.y = @max.z = -Float::INFINITY
+      self
+    end
+
+    def empty?
+      # self is a more robust check for empty than (volume <= 0) because volume can get positive with two negative axes
+      (@max.x < @min.x) || (@max.y < @min.y) || (@max.z < @min.z)
+    end
+
+    def center(target = Mittsu::Vector3.new)
+      target.add_vectors(@min, @max).multiply_scalar(0.5)
+    end
+
+    def size(target = Mittsu::Vector3.new)
+      target.sub_vectors(@max, @min)
+    end
+
+    def expand_by_point(point)
+      @min.min(point)
+      @max.max(point)
+      self
+    end
+
+    def expand_by_vector(vector)
+      @min.sub(vector)
+      @max.add(vector)
+      self
+    end
+
+    def expand_by_scalar(scalar)
+      @min.add_scalar(-scalar)
+      @max.add_scalar(scalar)
+      self
+    end
+
+    def contains_point?(point)
+      !(point.x < @min.x || point.x > @max.x ||
+        point.y < @min.y || point.y > @max.y ||
+        point.z < @min.z || point.z > @max.z)
+    end
+
+    def contains_box?(box)
+      ((@min.x <= box.min.x) && (box.max.x <= @max.x) &&
+        (@min.y <= box.min.y) && (box.max.y <= @max.y) &&
+        (@min.z <= box.min.z) && (box.max.z <= @max.z))
+    end
+
+    def parameter(point, target = nil)
+      # This can potentially have a divide by zero if the box
+      # has a size dimension of 0.
+      result = target || Mittsu::Vector3.new
+      result.set(
+        (point.x - @min.x) / (@max.x - @min.x),
+        (point.y - @min.y) / (@max.y - @min.y),
+        (point.z - @min.z) / (@max.z - @min.z)
+      )
+    end
+
+    def intersection_box?(box)
+      # using 6 splitting planes to rule out intersections.
+      !(box.max.x < @min.x || box.min.x > @max.x ||
+        box.max.y < @min.y || box.min.y > @max.y ||
+        box.max.z < @min.z || box.min.z > @max.z)
+    end
+
+    def clamp_point(point, target = Mittsu::Vector3.new)
+      target.copy(point).clamp(@min, @max)
+    end
+
+    def distance_to_point(point, target = Mittsu::Vector3.new)
+      target.copy(point).clamp(@min, @max).sub(point).length
+    end
+
+    def bounding_sphere(target = Mittsu::Sphere.new)
+      target.center = self.center
+      target.radius = self.size().length * 0.5
+      target
+    end
+
+    def intersect(box)
+      @min.max(box.min)
+      @max.min(box.max)
+      self
+    end
+
+    def union(box)
+      @min.min(box.min)
+      @max.max(box.max)
+      self
+    end
+
+    def apply_matrix4(matrix)
+      points = [
+        # NOTE: I am using a binary pattern to specify all 2^3 combinations below
+        Mittsu::Vector3.new(@min.x, @min.y, @min.z).apply_matrix4(matrix), # 000
+        Mittsu::Vector3.new(@min.x, @min.y, @max.z).apply_matrix4(matrix), # 001
+        Mittsu::Vector3.new(@min.x, @max.y, @min.z).apply_matrix4(matrix), # 010
+        Mittsu::Vector3.new(@min.x, @max.y, @max.z).apply_matrix4(matrix), # 011
+        Mittsu::Vector3.new(@max.x, @min.y, @min.z).apply_matrix4(matrix), # 100
+        Mittsu::Vector3.new(@max.x, @min.y, @max.z).apply_matrix4(matrix), # 101
+        Mittsu::Vector3.new(@max.x, @max.y, @min.z).apply_matrix4(matrix), # 110
+        Mittsu::Vector3.new(@max.x, @max.y, @max.z).apply_matrix4(matrix)  # 111
+      ]
+      self.make_empty
+      self.set_from_points(points)
+      self
+    end
+
+    def translate(offset)
+      @min.add(offset)
+      @max.add(offset)
+      self
+    end
+
+    def ==(box)
+      box.min == @min && box.max == @max
+    end
+
+    def clone
+      Mittsu::Box3.new.copy(self)
+    end
+
+  end
+end

data/lib/mittsu/math/color.rb

@@ -0,0 +1,252 @@
+require 'mittsu/math'
+
+module Mittsu
+  class Color
+    attr_accessor :r, :g, :b
+
+    def initialize(*args)
+      case args.length
+      when 3 then self.set_rgb(*args)
+      when 1 then self.set(args.first)
+      when 0 then self.set_rgb(1.0, 1.0, 1.0)
+      else raise ArgumentError, "Arguments must be (r, g, b), (color), or none"
+      end
+    end
+
+    def set(value)
+      case value
+      when Color
+        self.copy(value)
+      when Fixnum
+        self.set_hex(value)
+      when String
+        self.set_style(value)
+      else
+        raise ArgumentError, "Arguments must be Color, Fixnum or String"
+      end
+      self
+    end
+
+    def set_hex(hex)
+      hex = hex.floor
+      @r = (hex >> 16 & 255) / 255.0
+      @g = (hex >> 8 & 255) / 255.0
+      @b = (hex & 255) / 255.0
+      self
+    end
+
+    def set_rgb(r, g, b)
+      @r = r.to_f
+      @g = g.to_f
+      @b = b.to_f
+      self
+    end
+
+    def set_hsl(h, s, l)
+      # h,s,l ranges are in 0.0 - 1.0
+      if s.zero?
+        @r = @g = @b = l
+      else
+        p = l <= 0.5 ? l * (1.0 + s) : l + s - (l * s)
+        q = (2.0 * l) - p
+        @r = hue2rgb(q, p, h + 1.0 / 3.0)
+        @g = hue2rgb(q, p, h)
+        @b = hue2rgb(q, p, h - 1.0 / 3.0)
+      end
+      self
+    end
+
+    def set_style(style)
+      # rgb(255,0,0)
+      if /^rgb\((\d+), ?(\d+), ?(\d+)\)$/i =~ style
+        @r = [255.0, $1.to_f].min / 255.0
+        @g = [255.0, $2.to_f].min / 255.0
+        @b = [255.0, $3.to_f].min / 255.0
+        return self
+      end
+      # rgb(100%,0%,0%)
+      if /^rgb\((\d+)\%, ?(\d+)\%, ?(\d+)\%\)$/i =~ style
+        @r = [100.0, $1.to_f].min / 100.0
+        @g = [100.0, $2.to_f].min / 100.0
+        @b = [100.0, $3.to_f].min / 100.0
+        return self
+      end
+      # #ff0000
+      if /^\#([0-9a-f]{6})$/i =~ style
+        self.set_hex($1.hex)
+        return self
+      end
+      # #f00
+      if /^\#([0-9a-f])([0-9a-f])([0-9a-f])$/i =~ style
+        self.set_hex(($1 + $1 + $2 + $2 + $3 + $3).hex)
+        return self
+      end
+      # red
+      if /^(\w+)$/i =~ style
+        self.set_hex(Mittsu::ColorKeywords[style])
+        return self
+      end
+    end
+
+    def copy(color)
+      @r = color.r
+      @g = color.g
+      @b = color.b
+      self
+    end
+
+    def copy_gamma_to_linear(color, gamma_factor = 2.0)
+      @r = color.r ** gamma_factor
+      @g = color.g ** gamma_factor
+      @b = color.b ** gamma_factor
+      self
+    end
+
+    def copy_linear_to_gamma(color, gamma_factor = 2.0)
+      safe_inverse = (gamma_factor > 0) ? (1.0 / gamma_factor) : 1.0
+      @r = color.r ** safe_inverse
+      @g = color.g ** safe_inverse
+      @b = color.b ** safe_inverse
+      self
+    end
+
+    def convert_gamma_to_linear
+      rr, gg, bb = @r, @g, @b
+      @r = rr * rr
+      @g = gg * gg
+      @b = bb * bb
+      self
+    end
+
+    def convert_linear_to_gamma
+      @r = Math.sqrt(@r)
+      @g = Math.sqrt(@g)
+      @b = Math.sqrt(@b)
+      self
+    end
+
+    def hex
+      (@r * 255).to_i << 16 ^ (@g * 255).to_i << 8 ^ (@b * 255).to_i << 0
+    end
+
+    def hex_string
+      ('000000' + self.hex.to_s(16))[-6..-1]
+    end
+
+    def hsl(target = nil)
+      # h,s,l ranges are in 0.0 - 1.0
+      hsl = target || { h: 0.0, s: 0.0, l: 0.0 }
+      rr, gg, bb = @r, @g, @b
+      max = [r, g, b].max
+      min = [r, g, b].min
+      hue, saturation = nil, nil
+      lightness = (min + max) / 2.0
+      if min == max
+        hue = 0.0
+        saturation = 0.0
+      else
+        delta = max - min
+        saturation = lightness <= 0.5 ? delta / (max + min) : delta / (2.0 - max - min)
+        case max
+        when rr then hue = (gg - bb) / delta + (gg < bb ? 6.0 : 0.0)
+        when gg then hue = (bb - rr) / delta + 2.0
+        when bb then hue = (rr - gg) / delta + 4.0
+        end
+        hue /= 6.0
+      end
+      hsl[:h] = hue
+      hsl[:s] = saturation
+      hsl[:l] = lightness
+      hsl
+    end
+
+    def style
+      "rgb(#{ (@r * 255).to_i },#{ (@g * 255).to_i },#{ (@b * 255).to_i })"
+    end
+
+    def offset_hsl(h, s, l)
+      hsl = self.hsl
+      hsl[:h] += h
+      hsl[:s] += s
+      hsl[:l] += l
+      self.set_hsl(hsl[:h], hsl[:s], hsl[:l])
+      self
+    end
+
+    def add(color)
+      @r += color.r
+      @g += color.g
+      @b += color.b
+      self
+    end
+
+    def add_colors(color1, color2)
+      @r = color1.r + color2.r
+      @g = color1.g + color2.g
+      @b = color1.b + color2.b
+      self
+    end
+
+    def add_scalar(s)
+      @r += s
+      @g += s
+      @b += s
+      self
+    end
+
+    def multiply(color)
+      @r *= color.r
+      @g *= color.g
+      @b *= color.b
+      self
+    end
+
+    def multiply_scalar(s)
+      @r *= s
+      @g *= s
+      @b *= s
+      self
+    end
+
+    def lerp(color, alpha)
+      @r += (color.r - @r) * alpha
+      @g += (color.g - @g) * alpha
+      @b += (color.b - @b) * alpha
+      self
+    end
+
+    def equals(c)
+      (c.r == @r) && (c.g == @g) && (c.b == @b)
+    end
+
+    def from_array(array)
+      @r = array[0]
+      @g = array[1]
+      @b = array[2]
+      self
+    end
+
+    def to_array(array = [], offset = 0)
+      array[offset] = @r
+      array[offset + 1] = @g
+      array[offset + 2] = @b
+      array
+    end
+
+    def clone
+      Mittsu::Color.new(@r, @g, @b)
+    end
+
+    private
+
+    def hue2rgb(p, q, t)
+      t += 1.0 if t < 0.0
+      t -= 1.0 if t > 1.0
+      return p + (q - p) * 6.0 * t if t < 1.0 / 6.0
+      return q if t < 1.0 / 2.0
+      return p + (q - p) * 6.0 * (2.0 / 3.0 - t) if t < 2.0 / 3.0
+      p
+    end
+
+  end
+end