larb 0.1.0 → 1.0.0

data/lib/larb/mat4.rb

@@ -1,329 +0,0 @@
-# frozen_string_literal: true
-
-module Larb
-  class Mat4
-    attr_reader :data
-
-    def initialize(data = nil)
-      @data = data || Array.new(16, 0.0)
-      unless data
-        @data[0] = @data[5] = @data[10] = @data[15] = 1.0
-      end
-    end
-
-    def self.identity
-      new
-    end
-
-    def self.zero
-      new(Array.new(16, 0.0))
-    end
-
-    def self.translation(x, y, z)
-      m = identity
-      m[12] = x.to_f
-      m[13] = y.to_f
-      m[14] = z.to_f
-      m
-    end
-
-    def self.scaling(x, y, z)
-      m = zero
-      m[0] = x.to_f
-      m[5] = y.to_f
-      m[10] = z.to_f
-      m[15] = 1.0
-      m
-    end
-
-    def self.rotation_x(radians)
-      c = Math.cos(radians)
-      s = Math.sin(radians)
-      m = identity
-      m[5] = c
-      m[6] = s
-      m[9] = -s
-      m[10] = c
-      m
-    end
-
-    def self.rotation_y(radians)
-      c = Math.cos(radians)
-      s = Math.sin(radians)
-      m = identity
-      m[0] = c
-      m[2] = -s
-      m[8] = s
-      m[10] = c
-      m
-    end
-
-    def self.rotation_z(radians)
-      c = Math.cos(radians)
-      s = Math.sin(radians)
-      m = identity
-      m[0] = c
-      m[1] = s
-      m[4] = -s
-      m[5] = c
-      m
-    end
-
-    def self.rotation(axis, radians)
-      axis = axis.normalize
-      c = Math.cos(radians)
-      s = Math.sin(radians)
-      t = 1 - c
-      x = axis.x
-      y = axis.y
-      z = axis.z
-
-      new([
-        t * x * x + c,     t * x * y + s * z, t * x * z - s * y, 0,
-        t * x * y - s * z, t * y * y + c,     t * y * z + s * x, 0,
-        t * x * z + s * y, t * y * z - s * x, t * z * z + c,     0,
-        0,                 0,                 0,                 1
-      ])
-    end
-
-    def self.look_at(eye, target, up)
-      f = (target - eye).normalize
-      r = f.cross(up).normalize
-      u = r.cross(f)
-
-      new([
-        r.x,         u.x,         -f.x,        0,
-        r.y,         u.y,         -f.y,        0,
-        r.z,         u.z,         -f.z,        0,
-        -r.dot(eye), -u.dot(eye), f.dot(eye),  1
-      ])
-    end
-
-    def self.perspective(fov_y, aspect, near, far)
-      f = 1.0 / Math.tan(fov_y / 2.0)
-      nf = 1.0 / (near - far)
-
-      new([
-        f / aspect, 0, 0,                      0,
-        0,          f, 0,                      0,
-        0,          0, (far + near) * nf,     -1,
-        0,          0, 2 * far * near * nf,    0
-      ])
-    end
-
-    def self.orthographic(left, right, bottom, top, near, far)
-      rl = 1.0 / (right - left)
-      tb = 1.0 / (top - bottom)
-      fn = 1.0 / (far - near)
-
-      new([
-        2 * rl,                  0,                       0,                       0,
-        0,                       2 * tb,                  0,                       0,
-        0,                       0,                      -2 * fn,                  0,
-        -(right + left) * rl,   -(top + bottom) * tb,   -(far + near) * fn,       1
-      ])
-    end
-
-    def self.frustum(left, right, bottom, top, near, far)
-      rl = 1.0 / (right - left)
-      tb = 1.0 / (top - bottom)
-      nf = 1.0 / (near - far)
-
-      new([
-        2 * near * rl,           0,                       0,                       0,
-        0,                       2 * near * tb,           0,                       0,
-        (right + left) * rl,    (top + bottom) * tb,     (far + near) * nf,       -1,
-        0,                       0,                       2 * far * near * nf,     0
-      ])
-    end
-
-    def self.from_quaternion(q)
-      x, y, z, w = q.x, q.y, q.z, q.w
-
-      x2 = x + x
-      y2 = y + y
-      z2 = z + z
-
-      xx = x * x2
-      xy = x * y2
-      xz = x * z2
-      yy = y * y2
-      yz = y * z2
-      zz = z * z2
-      wx = w * x2
-      wy = w * y2
-      wz = w * z2
-
-      new([
-        1 - (yy + zz), xy + wz,       xz - wy,       0,
-        xy - wz,       1 - (xx + zz), yz + wx,       0,
-        xz + wy,       yz - wx,       1 - (xx + yy), 0,
-        0,             0,             0,             1
-      ])
-    end
-
-    def self.trs(translation, rotation, scale)
-      from_quaternion(rotation) * scaling(scale.x, scale.y, scale.z) *
-        self.translation(translation.x, translation.y, translation.z)
-    end
-
-    def [](i)
-      @data[i]
-    end
-
-    def []=(i, v)
-      @data[i] = v.to_f
-    end
-
-    def *(other)
-      case other
-      when Mat4
-        result = Array.new(16, 0.0)
-        4.times do |col|
-          4.times do |row|
-            4.times do |k|
-              result[col * 4 + row] += @data[k * 4 + row] * other[col * 4 + k]
-            end
-          end
-        end
-        Mat4.new(result)
-
-      when Vec4
-        Vec4.new(
-          @data[0] * other.x + @data[4] * other.y + @data[8] * other.z + @data[12] * other.w,
-          @data[1] * other.x + @data[5] * other.y + @data[9] * other.z + @data[13] * other.w,
-          @data[2] * other.x + @data[6] * other.y + @data[10] * other.z + @data[14] * other.w,
-          @data[3] * other.x + @data[7] * other.y + @data[11] * other.z + @data[15] * other.w
-        )
-
-      when Vec3
-        self * other.to_vec4
-      end
-    end
-
-    def transpose
-      Mat4.new([
-        @data[0], @data[4], @data[8],  @data[12],
-        @data[1], @data[5], @data[9],  @data[13],
-        @data[2], @data[6], @data[10], @data[14],
-        @data[3], @data[7], @data[11], @data[15]
-      ])
-    end
-
-    def inverse
-      m = @data
-      inv = Array.new(16)
-
-      inv[0]  =  m[5] * m[10] * m[15] - m[5] * m[11] * m[14] - m[9] * m[6] * m[15] + m[9] * m[7] * m[14] + m[13] * m[6] * m[11] - m[13] * m[7] * m[10]
-      inv[4]  = -m[4] * m[10] * m[15] + m[4] * m[11] * m[14] + m[8] * m[6] * m[15] - m[8] * m[7] * m[14] - m[12] * m[6] * m[11] + m[12] * m[7] * m[10]
-      inv[8]  =  m[4] * m[9] * m[15] - m[4] * m[11] * m[13] - m[8] * m[5] * m[15] + m[8] * m[7] * m[13] + m[12] * m[5] * m[11] - m[12] * m[7] * m[9]
-      inv[12] = -m[4] * m[9] * m[14] + m[4] * m[10] * m[13] + m[8] * m[5] * m[14] - m[8] * m[6] * m[13] - m[12] * m[5] * m[10] + m[12] * m[6] * m[9]
-
-      inv[1]  = -m[1] * m[10] * m[15] + m[1] * m[11] * m[14] + m[9] * m[2] * m[15] - m[9] * m[3] * m[14] - m[13] * m[2] * m[11] + m[13] * m[3] * m[10]
-      inv[5]  =  m[0] * m[10] * m[15] - m[0] * m[11] * m[14] - m[8] * m[2] * m[15] + m[8] * m[3] * m[14] + m[12] * m[2] * m[11] - m[12] * m[3] * m[10]
-      inv[9]  = -m[0] * m[9] * m[15] + m[0] * m[11] * m[13] + m[8] * m[1] * m[15] - m[8] * m[3] * m[13] - m[12] * m[1] * m[11] + m[12] * m[3] * m[9]
-      inv[13] =  m[0] * m[9] * m[14] - m[0] * m[10] * m[13] - m[8] * m[1] * m[14] + m[8] * m[2] * m[13] + m[12] * m[1] * m[10] - m[12] * m[2] * m[9]
-
-      inv[2]  =  m[1] * m[6] * m[15] - m[1] * m[7] * m[14] - m[5] * m[2] * m[15] + m[5] * m[3] * m[14] + m[13] * m[2] * m[7] - m[13] * m[3] * m[6]
-      inv[6]  = -m[0] * m[6] * m[15] + m[0] * m[7] * m[14] + m[4] * m[2] * m[15] - m[4] * m[3] * m[14] - m[12] * m[2] * m[7] + m[12] * m[3] * m[6]
-      inv[10] =  m[0] * m[5] * m[15] - m[0] * m[7] * m[13] - m[4] * m[1] * m[15] + m[4] * m[3] * m[13] + m[12] * m[1] * m[7] - m[12] * m[3] * m[5]
-      inv[14] = -m[0] * m[5] * m[14] + m[0] * m[6] * m[13] + m[4] * m[1] * m[14] - m[4] * m[2] * m[13] - m[12] * m[1] * m[6] + m[12] * m[2] * m[5]
-
-      inv[3]  = -m[1] * m[6] * m[11] + m[1] * m[7] * m[10] + m[5] * m[2] * m[11] - m[5] * m[3] * m[10] - m[9] * m[2] * m[7] + m[9] * m[3] * m[6]
-      inv[7]  =  m[0] * m[6] * m[11] - m[0] * m[7] * m[10] - m[4] * m[2] * m[11] + m[4] * m[3] * m[10] + m[8] * m[2] * m[7] - m[8] * m[3] * m[6]
-      inv[11] = -m[0] * m[5] * m[11] + m[0] * m[7] * m[9] + m[4] * m[1] * m[11] - m[4] * m[3] * m[9] - m[8] * m[1] * m[7] + m[8] * m[3] * m[5]
-      inv[15] =  m[0] * m[5] * m[10] - m[0] * m[6] * m[9] - m[4] * m[1] * m[10] + m[4] * m[2] * m[9] + m[8] * m[1] * m[6] - m[8] * m[2] * m[5]
-
-      det = m[0] * inv[0] + m[1] * inv[4] + m[2] * inv[8] + m[3] * inv[12]
-      raise "Matrix is not invertible" if det.abs < 1e-10
-
-      det = 1.0 / det
-      Mat4.new(inv.map { |v| v * det })
-    end
-
-    def to_a
-      @data.dup
-    end
-
-    def determinant
-      m = @data
-      m[0] * (m[5] * (m[10] * m[15] - m[11] * m[14]) -
-              m[9] * (m[6] * m[15] - m[7] * m[14]) +
-              m[13] * (m[6] * m[11] - m[7] * m[10])) -
-        m[4] * (m[1] * (m[10] * m[15] - m[11] * m[14]) -
-                m[9] * (m[2] * m[15] - m[3] * m[14]) +
-                m[13] * (m[2] * m[11] - m[3] * m[10])) +
-        m[8] * (m[1] * (m[6] * m[15] - m[7] * m[14]) -
-                m[5] * (m[2] * m[15] - m[3] * m[14]) +
-                m[13] * (m[2] * m[7] - m[3] * m[6])) -
-        m[12] * (m[1] * (m[6] * m[11] - m[7] * m[10]) -
-                 m[5] * (m[2] * m[11] - m[3] * m[10]) +
-                 m[9] * (m[2] * m[7] - m[3] * m[6]))
-    end
-
-    def +(other)
-      Mat4.new(@data.zip(other.data).map { |a, b| a + b })
-    end
-
-    def -(other)
-      Mat4.new(@data.zip(other.data).map { |a, b| a - b })
-    end
-
-    def ==(other)
-      return false unless other.is_a?(Mat4)
-
-      @data == other.data
-    end
-
-    def near?(other, epsilon = 1e-6)
-      @data.zip(other.data).all? { |a, b| (a - b).abs < epsilon }
-    end
-
-    def extract_translation
-      Vec3.new(@data[12], @data[13], @data[14])
-    end
-
-    def extract_scale
-      sx = Vec3.new(@data[0], @data[1], @data[2]).length
-      sy = Vec3.new(@data[4], @data[5], @data[6]).length
-      sz = Vec3.new(@data[8], @data[9], @data[10]).length
-      Vec3.new(sx, sy, sz)
-    end
-
-    def extract_rotation
-      scale = extract_scale
-      m00 = @data[0] / scale.x
-      m01 = @data[1] / scale.x
-      m02 = @data[2] / scale.x
-      m10 = @data[4] / scale.y
-      m11 = @data[5] / scale.y
-      m12 = @data[6] / scale.y
-      m20 = @data[8] / scale.z
-      m21 = @data[9] / scale.z
-      m22 = @data[10] / scale.z
-
-      trace = m00 + m11 + m22
-      if trace > 0
-        s = 0.5 / Math.sqrt(trace + 1.0)
-        Quat.new((m12 - m21) * s, (m20 - m02) * s, (m01 - m10) * s, 0.25 / s)
-      elsif m00 > m11 && m00 > m22
-        s = 2.0 * Math.sqrt(1.0 + m00 - m11 - m22)
-        Quat.new(0.25 * s, (m10 + m01) / s, (m20 + m02) / s, (m12 - m21) / s)
-      elsif m11 > m22
-        s = 2.0 * Math.sqrt(1.0 + m11 - m00 - m22)
-        Quat.new((m10 + m01) / s, 0.25 * s, (m21 + m12) / s, (m20 - m02) / s)
-      else
-        s = 2.0 * Math.sqrt(1.0 + m22 - m00 - m11)
-        Quat.new((m20 + m02) / s, (m21 + m12) / s, 0.25 * s, (m01 - m10) / s)
-      end
-    end
-
-    def inspect
-      "Mat4[\n" \
-      "  #{@data[0..3].map { |v| format('%8.4f', v) }.join(', ')}\n" \
-      "  #{@data[4..7].map { |v| format('%8.4f', v) }.join(', ')}\n" \
-      "  #{@data[8..11].map { |v| format('%8.4f', v) }.join(', ')}\n" \
-      "  #{@data[12..15].map { |v| format('%8.4f', v) }.join(', ')}\n]"
-    end
-  end
-end

data/lib/larb/quat.rb

@@ -1,238 +0,0 @@
-# frozen_string_literal: true
-
-module Larb
-  class Quat
-    attr_accessor :x, :y, :z, :w
-
-    def initialize(x = 0.0, y = 0.0, z = 0.0, w = 1.0)
-      @x = x.to_f
-      @y = y.to_f
-      @z = z.to_f
-      @w = w.to_f
-    end
-
-    def self.[](x, y, z, w)
-      new(x, y, z, w)
-    end
-
-    def self.identity
-      new(0, 0, 0, 1)
-    end
-
-    def self.from_axis_angle(axis, radians)
-      half = radians * 0.5
-      s = Math.sin(half)
-      axis = axis.normalize
-      new(axis.x * s, axis.y * s, axis.z * s, Math.cos(half))
-    end
-
-    def self.from_euler(x, y, z)
-      cx = Math.cos(x * 0.5)
-      sx = Math.sin(x * 0.5)
-      cy = Math.cos(y * 0.5)
-      sy = Math.sin(y * 0.5)
-      cz = Math.cos(z * 0.5)
-      sz = Math.sin(z * 0.5)
-
-      new(
-        sx * cy * cz - cx * sy * sz,
-        cx * sy * cz + sx * cy * sz,
-        cx * cy * sz - sx * sy * cz,
-        cx * cy * cz + sx * sy * sz
-      )
-    end
-
-    def self.look_rotation(forward, up = Vec3.up)
-      forward = forward.normalize
-      right = up.cross(forward).normalize
-      up = forward.cross(right)
-
-      m00 = right.x
-      m01 = up.x
-      m02 = forward.x
-      m10 = right.y
-      m11 = up.y
-      m12 = forward.y
-      m20 = right.z
-      m21 = up.z
-      m22 = forward.z
-
-      trace = m00 + m11 + m22
-      if trace > 0
-        s = 0.5 / Math.sqrt(trace + 1.0)
-        new((m21 - m12) * s, (m02 - m20) * s, (m10 - m01) * s, 0.25 / s)
-      elsif m00 > m11 && m00 > m22
-        s = 2.0 * Math.sqrt(1.0 + m00 - m11 - m22)
-        new(0.25 * s, (m01 + m10) / s, (m02 + m20) / s, (m21 - m12) / s)
-      elsif m11 > m22
-        s = 2.0 * Math.sqrt(1.0 + m11 - m00 - m22)
-        new((m01 + m10) / s, 0.25 * s, (m12 + m21) / s, (m02 - m20) / s)
-      else
-        s = 2.0 * Math.sqrt(1.0 + m22 - m00 - m11)
-        new((m02 + m20) / s, (m12 + m21) / s, 0.25 * s, (m10 - m01) / s)
-      end
-    end
-
-    def *(other)
-      case other
-      when Quat
-        Quat.new(
-          @w * other.x + @x * other.w + @y * other.z - @z * other.y,
-          @w * other.y - @x * other.z + @y * other.w + @z * other.x,
-          @w * other.z + @x * other.y - @y * other.x + @z * other.w,
-          @w * other.w - @x * other.x - @y * other.y - @z * other.z
-        )
-      when Vec3
-        qv = Vec3.new(@x, @y, @z)
-        uv = qv.cross(other)
-        uuv = qv.cross(uv)
-        other + (uv * @w + uuv) * 2
-      when Numeric
-        Quat.new(@x * other, @y * other, @z * other, @w * other)
-      end
-    end
-
-    def +(other)
-      Quat.new(@x + other.x, @y + other.y, @z + other.z, @w + other.w)
-    end
-
-    def -(other)
-      Quat.new(@x - other.x, @y - other.y, @z - other.z, @w - other.w)
-    end
-
-    def -@
-      Quat.new(-@x, -@y, -@z, -@w)
-    end
-
-    def dot(other)
-      @x * other.x + @y * other.y + @z * other.z + @w * other.w
-    end
-
-    def length
-      Math.sqrt(length_squared)
-    end
-
-    def length_squared
-      @x * @x + @y * @y + @z * @z + @w * @w
-    end
-
-    def normalize
-      l = length
-      Quat.new(@x / l, @y / l, @z / l, @w / l)
-    end
-
-    def normalize!
-      l = length
-      @x /= l
-      @y /= l
-      @z /= l
-      @w /= l
-      self
-    end
-
-    def conjugate
-      Quat.new(-@x, -@y, -@z, @w)
-    end
-
-    def inverse
-      len_sq = length_squared
-      Quat.new(-@x / len_sq, -@y / len_sq, -@z / len_sq, @w / len_sq)
-    end
-
-    def lerp(other, t)
-      Quat.new(
-        @x + (other.x - @x) * t,
-        @y + (other.y - @y) * t,
-        @z + (other.z - @z) * t,
-        @w + (other.w - @w) * t
-      ).normalize
-    end
-
-    def slerp(other, t)
-      dot_val = dot(other)
-
-      other = -other if dot_val < 0
-      dot_val = dot_val.abs
-
-      if dot_val > 0.9995
-        return lerp(other, t)
-      end
-
-      theta_0 = Math.acos(dot_val.clamp(-1.0, 1.0))
-      theta = theta_0 * t
-      sin_theta = Math.sin(theta)
-      sin_theta_0 = Math.sin(theta_0)
-
-      s0 = Math.cos(theta) - dot_val * sin_theta / sin_theta_0
-      s1 = sin_theta / sin_theta_0
-
-      Quat.new(
-        @x * s0 + other.x * s1,
-        @y * s0 + other.y * s1,
-        @z * s0 + other.z * s1,
-        @w * s0 + other.w * s1
-      )
-    end
-
-    def to_axis_angle
-      angle = 2 * Math.acos(@w.clamp(-1.0, 1.0))
-      s = Math.sqrt(1 - @w * @w)
-      if s < 0.001
-        axis = Vec3.new(1, 0, 0)
-      else
-        axis = Vec3.new(@x / s, @y / s, @z / s)
-      end
-      [axis, angle]
-    end
-
-    def to_euler
-      sinr_cosp = 2 * (@w * @x + @y * @z)
-      cosr_cosp = 1 - 2 * (@x * @x + @y * @y)
-      roll = Math.atan2(sinr_cosp, cosr_cosp)
-
-      sinp = 2 * (@w * @y - @z * @x)
-      pitch = if sinp.abs >= 1
-                Math.copysign(Math::PI / 2, sinp)
-              else
-                Math.asin(sinp)
-              end
-
-      siny_cosp = 2 * (@w * @z + @x * @y)
-      cosy_cosp = 1 - 2 * (@y * @y + @z * @z)
-      yaw = Math.atan2(siny_cosp, cosy_cosp)
-
-      Vec3.new(roll, pitch, yaw)
-    end
-
-    def to_mat4
-      Mat4.from_quaternion(self)
-    end
-
-    def to_a
-      [@x, @y, @z, @w]
-    end
-
-    def [](i)
-      to_a[i]
-    end
-
-    def ==(other)
-      return false unless other.is_a?(Quat)
-
-      @x == other.x && @y == other.y && @z == other.z && @w == other.w
-    end
-
-    def near?(other, epsilon = 1e-6)
-      (@x - other.x).abs < epsilon &&
-        (@y - other.y).abs < epsilon &&
-        (@z - other.z).abs < epsilon &&
-        (@w - other.w).abs < epsilon
-    end
-
-    def inspect
-      "Quat[#{@x}, #{@y}, #{@z}, #{@w}]"
-    end
-
-    alias to_s inspect
-  end
-end