3rb 0.1.0

data/lib/3rb/math/matrix3.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class Matrix3
+    attr_reader :elements
+
+    def initialize
+      @elements = [
+        1.0, 0.0, 0.0,
+        0.0, 1.0, 0.0,
+        0.0, 0.0, 1.0
+      ]
+    end
+
+    def set(n11, n12, n13, n21, n22, n23, n31, n32, n33)
+      @elements[0] = n11.to_f
+      @elements[3] = n12.to_f
+      @elements[6] = n13.to_f
+      @elements[1] = n21.to_f
+      @elements[4] = n22.to_f
+      @elements[7] = n23.to_f
+      @elements[2] = n31.to_f
+      @elements[5] = n32.to_f
+      @elements[8] = n33.to_f
+      self
+    end
+
+    def identity
+      set(
+        1, 0, 0,
+        0, 1, 0,
+        0, 0, 1
+      )
+    end
+
+    def copy(m)
+      @elements = m.elements.dup
+      self
+    end
+
+    def clone
+      Matrix3.new.copy(self)
+    end
+
+    def *(other)
+      clone.multiply!(other)
+    end
+
+    def multiply!(other)
+      ae = @elements
+      be = other.elements
+
+      a11 = ae[0]
+      a12 = ae[3]
+      a13 = ae[6]
+      a21 = ae[1]
+      a22 = ae[4]
+      a23 = ae[7]
+      a31 = ae[2]
+      a32 = ae[5]
+      a33 = ae[8]
+
+      b11 = be[0]
+      b12 = be[3]
+      b13 = be[6]
+      b21 = be[1]
+      b22 = be[4]
+      b23 = be[7]
+      b31 = be[2]
+      b32 = be[5]
+      b33 = be[8]
+
+      @elements[0] = a11 * b11 + a12 * b21 + a13 * b31
+      @elements[3] = a11 * b12 + a12 * b22 + a13 * b32
+      @elements[6] = a11 * b13 + a12 * b23 + a13 * b33
+
+      @elements[1] = a21 * b11 + a22 * b21 + a23 * b31
+      @elements[4] = a21 * b12 + a22 * b22 + a23 * b32
+      @elements[7] = a21 * b13 + a22 * b23 + a23 * b33
+
+      @elements[2] = a31 * b11 + a32 * b21 + a33 * b31
+      @elements[5] = a31 * b12 + a32 * b22 + a33 * b32
+      @elements[8] = a31 * b13 + a32 * b23 + a33 * b33
+
+      self
+    end
+
+    def premultiply!(other)
+      tmp = other * self
+      copy(tmp)
+    end
+
+    def determinant
+      a = @elements[0]
+      b = @elements[3]
+      c = @elements[6]
+      d = @elements[1]
+      e = @elements[4]
+      f = @elements[7]
+      g = @elements[2]
+      h = @elements[5]
+      i = @elements[8]
+
+      a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g
+    end
+
+    def transpose
+      clone.transpose!
+    end
+
+    def transpose!
+      tmp = @elements[1]
+      @elements[1] = @elements[3]
+      @elements[3] = tmp
+
+      tmp = @elements[2]
+      @elements[2] = @elements[6]
+      @elements[6] = tmp
+
+      tmp = @elements[5]
+      @elements[5] = @elements[7]
+      @elements[7] = tmp
+
+      self
+    end
+
+    def invert
+      clone.invert!
+    end
+
+    def invert!
+      e = @elements
+
+      n11 = e[0]
+      n21 = e[1]
+      n31 = e[2]
+      n12 = e[3]
+      n22 = e[4]
+      n32 = e[5]
+      n13 = e[6]
+      n23 = e[7]
+      n33 = e[8]
+
+      t11 = n33 * n22 - n32 * n23
+      t12 = n32 * n13 - n33 * n12
+      t13 = n23 * n12 - n22 * n13
+
+      det = n11 * t11 + n21 * t12 + n31 * t13
+
+      return identity if det.zero?
+
+      det_inv = 1.0 / det
+
+      e[0] = t11 * det_inv
+      e[1] = (n31 * n23 - n33 * n21) * det_inv
+      e[2] = (n32 * n21 - n31 * n22) * det_inv
+
+      e[3] = t12 * det_inv
+      e[4] = (n33 * n11 - n31 * n13) * det_inv
+      e[5] = (n31 * n12 - n32 * n11) * det_inv
+
+      e[6] = t13 * det_inv
+      e[7] = (n21 * n13 - n23 * n11) * det_inv
+      e[8] = (n22 * n11 - n21 * n12) * det_inv
+
+      self
+    end
+
+    def set_from_matrix4(m)
+      me = m.elements
+
+      set(
+        me[0], me[4], me[8],
+        me[1], me[5], me[9],
+        me[2], me[6], me[10]
+      )
+    end
+
+    def get_normal_matrix(matrix4)
+      set_from_matrix4(matrix4).invert!.transpose!
+    end
+
+    def make_rotation(theta)
+      c = Math.cos(theta)
+      s = Math.sin(theta)
+
+      set(
+        c, -s, 0,
+        s, c, 0,
+        0, 0, 1
+      )
+    end
+
+    def make_scale(sx, sy)
+      set(
+        sx, 0, 0,
+        0, sy, 0,
+        0, 0, 1
+      )
+    end
+
+    def make_translation(tx, ty)
+      set(
+        1, 0, tx,
+        0, 1, ty,
+        0, 0, 1
+      )
+    end
+
+    def scale!(sx, sy)
+      @elements[0] *= sx
+      @elements[3] *= sx
+      @elements[6] *= sx
+      @elements[1] *= sy
+      @elements[4] *= sy
+      @elements[7] *= sy
+      self
+    end
+
+    def rotate!(theta)
+      c = Math.cos(theta)
+      s = Math.sin(theta)
+
+      a11 = @elements[0]
+      a12 = @elements[3]
+      a13 = @elements[6]
+      a21 = @elements[1]
+      a22 = @elements[4]
+      a23 = @elements[7]
+
+      @elements[0] = c * a11 + s * a21
+      @elements[3] = c * a12 + s * a22
+      @elements[6] = c * a13 + s * a23
+
+      @elements[1] = -s * a11 + c * a21
+      @elements[4] = -s * a12 + c * a22
+      @elements[7] = -s * a13 + c * a23
+
+      self
+    end
+
+    def translate!(tx, ty)
+      @elements[0] += tx * @elements[2]
+      @elements[3] += tx * @elements[5]
+      @elements[6] += tx * @elements[8]
+      @elements[1] += ty * @elements[2]
+      @elements[4] += ty * @elements[5]
+      @elements[7] += ty * @elements[8]
+      self
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Matrix3)
+
+      @elements.each_with_index do |e, i|
+        return false if (e - other.elements[i]).abs > Float::EPSILON
+      end
+      true
+    end
+
+    def to_a
+      @elements.dup
+    end
+
+    def inspect
+      "#<Sunrb::Matrix3 #{@elements.inspect}>"
+    end
+  end
+end