larb 0.1.0 → 1.0.0

data/lib/larb/color.rb

@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-
-module Larb
-  class Color
-    attr_accessor :r, :g, :b, :a
-
-    def initialize(r = 0.0, g = 0.0, b = 0.0, a = 1.0)
-      @r = r.to_f
-      @g = g.to_f
-      @b = b.to_f
-      @a = a.to_f
-    end
-
-    def self.[](r, g, b, a = 1.0)
-      new(r, g, b, a)
-    end
-
-    def self.rgb(r, g, b)
-      new(r, g, b, 1.0)
-    end
-
-    def self.rgba(r, g, b, a)
-      new(r, g, b, a)
-    end
-
-    def self.from_bytes(r, g, b, a = 255)
-      new(r / 255.0, g / 255.0, b / 255.0, a / 255.0)
-    end
-
-    def self.from_hex(hex)
-      hex = hex.delete("#")
-      r = hex[0..1].to_i(16) / 255.0
-      g = hex[2..3].to_i(16) / 255.0
-      b = hex[4..5].to_i(16) / 255.0
-      a = hex.length > 6 ? hex[6..7].to_i(16) / 255.0 : 1.0
-      new(r, g, b, a)
-    end
-
-    def self.black
-      new(0, 0, 0, 1)
-    end
-
-    def self.white
-      new(1, 1, 1, 1)
-    end
-
-    def self.red
-      new(1, 0, 0, 1)
-    end
-
-    def self.green
-      new(0, 1, 0, 1)
-    end
-
-    def self.blue
-      new(0, 0, 1, 1)
-    end
-
-    def self.yellow
-      new(1, 1, 0, 1)
-    end
-
-    def self.cyan
-      new(0, 1, 1, 1)
-    end
-
-    def self.magenta
-      new(1, 0, 1, 1)
-    end
-
-    def self.transparent
-      new(0, 0, 0, 0)
-    end
-
-    def +(other)
-      Color.new(@r + other.r, @g + other.g, @b + other.b, @a + other.a)
-    end
-
-    def -(other)
-      Color.new(@r - other.r, @g - other.g, @b - other.b, @a - other.a)
-    end
-
-    def *(scalar)
-      case scalar
-      when Numeric
-        Color.new(@r * scalar, @g * scalar, @b * scalar, @a * scalar)
-      when Color
-        Color.new(@r * scalar.r, @g * scalar.g, @b * scalar.b, @a * scalar.a)
-      end
-    end
-
-    def lerp(other, t)
-      Color.new(
-        @r + (other.r - @r) * t,
-        @g + (other.g - @g) * t,
-        @b + (other.b - @b) * t,
-        @a + (other.a - @a) * t
-      )
-    end
-
-    def clamp
-      Color.new(
-        @r.clamp(0.0, 1.0),
-        @g.clamp(0.0, 1.0),
-        @b.clamp(0.0, 1.0),
-        @a.clamp(0.0, 1.0)
-      )
-    end
-
-    def to_bytes
-      [(@r * 255).round.clamp(0, 255),
-       (@g * 255).round.clamp(0, 255),
-       (@b * 255).round.clamp(0, 255),
-       (@a * 255).round.clamp(0, 255)]
-    end
-
-    def to_hex
-      r, g, b, a = to_bytes
-      format("#%02x%02x%02x%02x", r, g, b, a)
-    end
-
-    def to_vec3
-      Vec3.new(@r, @g, @b)
-    end
-
-    def to_vec4
-      Vec4.new(@r, @g, @b, @a)
-    end
-
-    def to_a
-      [@r, @g, @b, @a]
-    end
-
-    def self.from_vec4(v)
-      new(v.x, v.y, v.z, v.w)
-    end
-
-    def self.from_vec3(v, a = 1.0)
-      new(v.x, v.y, v.z, a)
-    end
-
-    def inspect
-      "Color[#{@r}, #{@g}, #{@b}, #{@a}]"
-    end
-
-    alias to_s inspect
-  end
-end

data/lib/larb/mat2.rb

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-module Larb
-  class Mat2
-    attr_reader :data
-
-    def initialize(data = nil)
-      @data = data || [1.0, 0.0, 0.0, 1.0]
-    end
-
-    def self.identity
-      new
-    end
-
-    def self.zero
-      new([0.0, 0.0, 0.0, 0.0])
-    end
-
-    def self.rotation(radians)
-      c = Math.cos(radians)
-      s = Math.sin(radians)
-      new([c, s, -s, c])
-    end
-
-    def self.scaling(x, y)
-      new([x.to_f, 0.0, 0.0, y.to_f])
-    end
-
-    def self.from_vec2(v1, v2)
-      new([v1.x, v1.y, v2.x, v2.y])
-    end
-
-    def [](i)
-      @data[i]
-    end
-
-    def []=(i, v)
-      @data[i] = v.to_f
-    end
-
-    def *(other)
-      case other
-      when Mat2
-        a = @data
-        b = other.data
-        Mat2.new([
-          a[0] * b[0] + a[2] * b[1],
-          a[1] * b[0] + a[3] * b[1],
-          a[0] * b[2] + a[2] * b[3],
-          a[1] * b[2] + a[3] * b[3]
-        ])
-      when Vec2
-        Vec2.new(
-          @data[0] * other.x + @data[2] * other.y,
-          @data[1] * other.x + @data[3] * other.y
-        )
-      when Numeric
-        Mat2.new(@data.map { |v| v * other })
-      end
-    end
-
-    def +(other)
-      Mat2.new(@data.zip(other.data).map { |a, b| a + b })
-    end
-
-    def -(other)
-      Mat2.new(@data.zip(other.data).map { |a, b| a - b })
-    end
-
-    def determinant
-      @data[0] * @data[3] - @data[2] * @data[1]
-    end
-
-    def inverse
-      det = determinant
-      raise "Matrix is not invertible" if det.abs < 1e-10
-
-      inv_det = 1.0 / det
-      Mat2.new([
-        @data[3] * inv_det,
-        -@data[1] * inv_det,
-        -@data[2] * inv_det,
-        @data[0] * inv_det
-      ])
-    end
-
-    def transpose
-      Mat2.new([@data[0], @data[2], @data[1], @data[3]])
-    end
-
-    def adjoint
-      Mat2.new([@data[3], -@data[1], -@data[2], @data[0]])
-    end
-
-    def frobenius_norm
-      Math.sqrt(@data.sum { |v| v * v })
-    end
-
-    def to_a
-      @data.dup
-    end
-
-    def ==(other)
-      return false unless other.is_a?(Mat2)
-
-      @data == other.data
-    end
-
-    def near?(other, epsilon = 1e-6)
-      @data.zip(other.data).all? { |a, b| (a - b).abs < epsilon }
-    end
-
-    def inspect
-      "Mat2[#{@data[0]}, #{@data[1]}, #{@data[2]}, #{@data[3]}]"
-    end
-
-    alias to_s inspect
-  end
-end

data/lib/larb/mat2d.rb

@@ -1,180 +0,0 @@
-# frozen_string_literal: true
-
-module Larb
-  # 2D affine transformation matrix (2x3)
-  # Layout: [a, b, c, d, tx, ty]
-  # Represents:
-  # | a  c  tx |
-  # | b  d  ty |
-  # | 0  0  1  |
-  class Mat2d
-    attr_reader :data
-
-    def initialize(data = nil)
-      @data = data || [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]
-    end
-
-    def self.identity
-      new
-    end
-
-    def self.zero
-      new([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])
-    end
-
-    def self.translation(x, y)
-      new([1.0, 0.0, 0.0, 1.0, x.to_f, y.to_f])
-    end
-
-    def self.rotation(radians)
-      c = Math.cos(radians)
-      s = Math.sin(radians)
-      new([c, s, -s, c, 0.0, 0.0])
-    end
-
-    def self.scaling(x, y)
-      new([x.to_f, 0.0, 0.0, y.to_f, 0.0, 0.0])
-    end
-
-    def self.from_rotation_translation_scale(rotation, translation, scale)
-      c = Math.cos(rotation)
-      s = Math.sin(rotation)
-      new([
-        c * scale.x,
-        s * scale.x,
-        -s * scale.y,
-        c * scale.y,
-        translation.x,
-        translation.y
-      ])
-    end
-
-    def [](i)
-      @data[i]
-    end
-
-    def []=(i, v)
-      @data[i] = v.to_f
-    end
-
-    def *(other)
-      case other
-      when Mat2d
-        a = @data
-        b = other.data
-        Mat2d.new([
-          a[0] * b[0] + a[2] * b[1],
-          a[1] * b[0] + a[3] * b[1],
-          a[0] * b[2] + a[2] * b[3],
-          a[1] * b[2] + a[3] * b[3],
-          a[0] * b[4] + a[2] * b[5] + a[4],
-          a[1] * b[4] + a[3] * b[5] + a[5]
-        ])
-      when Vec2
-        Vec2.new(
-          @data[0] * other.x + @data[2] * other.y + @data[4],
-          @data[1] * other.x + @data[3] * other.y + @data[5]
-        )
-      when Numeric
-        Mat2d.new(@data.map { |v| v * other })
-      end
-    end
-
-    def +(other)
-      Mat2d.new(@data.zip(other.data).map { |a, b| a + b })
-    end
-
-    def -(other)
-      Mat2d.new(@data.zip(other.data).map { |a, b| a - b })
-    end
-
-    def determinant
-      @data[0] * @data[3] - @data[1] * @data[2]
-    end
-
-    def inverse
-      a = @data
-      det = determinant
-      raise "Matrix is not invertible" if det.abs < 1e-10
-
-      inv_det = 1.0 / det
-      Mat2d.new([
-        a[3] * inv_det,
-        -a[1] * inv_det,
-        -a[2] * inv_det,
-        a[0] * inv_det,
-        (a[2] * a[5] - a[3] * a[4]) * inv_det,
-        (a[1] * a[4] - a[0] * a[5]) * inv_det
-      ])
-    end
-
-    def translate(x, y)
-      a = @data
-      Mat2d.new([
-        a[0], a[1], a[2], a[3],
-        a[0] * x + a[2] * y + a[4],
-        a[1] * x + a[3] * y + a[5]
-      ])
-    end
-
-    def rotate(radians)
-      self * Mat2d.rotation(radians)
-    end
-
-    def scale(x, y)
-      a = @data
-      Mat2d.new([
-        a[0] * x, a[1] * x,
-        a[2] * y, a[3] * y,
-        a[4], a[5]
-      ])
-    end
-
-    def extract_translation
-      Vec2.new(@data[4], @data[5])
-    end
-
-    def extract_rotation
-      Math.atan2(@data[1], @data[0])
-    end
-
-    def extract_scale
-      Vec2.new(
-        Math.sqrt(@data[0] * @data[0] + @data[1] * @data[1]),
-        Math.sqrt(@data[2] * @data[2] + @data[3] * @data[3])
-      )
-    end
-
-    def frobenius_norm
-      Math.sqrt(@data.sum { |v| v * v })
-    end
-
-    def to_mat3
-      Mat3.new([
-        @data[0], @data[1], 0,
-        @data[2], @data[3], 0,
-        @data[4], @data[5], 1
-      ])
-    end
-
-    def to_a
-      @data.dup
-    end
-
-    def ==(other)
-      return false unless other.is_a?(Mat2d)
-
-      @data == other.data
-    end
-
-    def near?(other, epsilon = 1e-6)
-      @data.zip(other.data).all? { |a, b| (a - b).abs < epsilon }
-    end
-
-    def inspect
-      "Mat2d[#{@data.map { |v| format('%.4f', v) }.join(', ')}]"
-    end
-
-    alias to_s inspect
-  end
-end

data/lib/larb/mat3.rb

@@ -1,238 +0,0 @@
-# frozen_string_literal: true
-
-module Larb
-  class Mat3
-    attr_reader :data
-
-    def initialize(data = nil)
-      @data = data || [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0]
-    end
-
-    def self.identity
-      new
-    end
-
-    def self.zero
-      new(Array.new(9, 0.0))
-    end
-
-    def self.from_mat4(m)
-      new([
-        m[0], m[1], m[2],
-        m[4], m[5], m[6],
-        m[8], m[9], m[10]
-      ])
-    end
-
-    def self.from_mat2d(m)
-      new([
-        m[0], m[1], 0,
-        m[2], m[3], 0,
-        m[4], m[5], 1
-      ])
-    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
-      yx = y * x2
-      yy = y * y2
-      zx = z * x2
-      zy = z * y2
-      zz = z * z2
-      wx = w * x2
-      wy = w * y2
-      wz = w * z2
-
-      new([
-        1 - yy - zz, yx + wz, zx - wy,
-        yx - wz, 1 - xx - zz, zy + wx,
-        zx + wy, zy - wx, 1 - xx - yy
-      ])
-    end
-
-    def self.normal_from_mat4(m)
-      from_mat4(m).inverse.transpose
-    end
-
-    def self.projection(width, height)
-      new([
-        2.0 / width, 0, 0,
-        0, -2.0 / height, 0,
-        -1, 1, 1
-      ])
-    end
-
-    def self.translation(x, y)
-      new([
-        1, 0, 0,
-        0, 1, 0,
-        x.to_f, y.to_f, 1
-      ])
-    end
-
-    def self.rotation(radians)
-      c = Math.cos(radians)
-      s = Math.sin(radians)
-      new([
-        c, s, 0,
-        -s, c, 0,
-        0, 0, 1
-      ])
-    end
-
-    def self.scaling(x, y)
-      new([
-        x.to_f, 0, 0,
-        0, y.to_f, 0,
-        0, 0, 1
-      ])
-    end
-
-    def [](i)
-      @data[i]
-    end
-
-    def []=(i, v)
-      @data[i] = v.to_f
-    end
-
-    def *(other)
-      case other
-      when Mat3
-        a = @data
-        b = other.data
-        Mat3.new([
-          a[0] * b[0] + a[3] * b[1] + a[6] * b[2],
-          a[1] * b[0] + a[4] * b[1] + a[7] * b[2],
-          a[2] * b[0] + a[5] * b[1] + a[8] * b[2],
-          a[0] * b[3] + a[3] * b[4] + a[6] * b[5],
-          a[1] * b[3] + a[4] * b[4] + a[7] * b[5],
-          a[2] * b[3] + a[5] * b[4] + a[8] * b[5],
-          a[0] * b[6] + a[3] * b[7] + a[6] * b[8],
-          a[1] * b[6] + a[4] * b[7] + a[7] * b[8],
-          a[2] * b[6] + a[5] * b[7] + a[8] * b[8]
-        ])
-      when Vec3
-        Vec3.new(
-          @data[0] * other.x + @data[3] * other.y + @data[6] * other.z,
-          @data[1] * other.x + @data[4] * other.y + @data[7] * other.z,
-          @data[2] * other.x + @data[5] * other.y + @data[8] * other.z
-        )
-      when Numeric
-        Mat3.new(@data.map { |v| v * other })
-      end
-    end
-
-    def +(other)
-      Mat3.new(@data.zip(other.data).map { |a, b| a + b })
-    end
-
-    def -(other)
-      Mat3.new(@data.zip(other.data).map { |a, b| a - b })
-    end
-
-    def determinant
-      a = @data
-      a[0] * (a[4] * a[8] - a[5] * a[7]) -
-        a[3] * (a[1] * a[8] - a[2] * a[7]) +
-        a[6] * (a[1] * a[5] - a[2] * a[4])
-    end
-
-    def inverse
-      a = @data
-      det = determinant
-      raise "Matrix is not invertible" if det.abs < 1e-10
-
-      inv_det = 1.0 / det
-      Mat3.new([
-        (a[4] * a[8] - a[5] * a[7]) * inv_det,
-        (a[2] * a[7] - a[1] * a[8]) * inv_det,
-        (a[1] * a[5] - a[2] * a[4]) * inv_det,
-        (a[5] * a[6] - a[3] * a[8]) * inv_det,
-        (a[0] * a[8] - a[2] * a[6]) * inv_det,
-        (a[2] * a[3] - a[0] * a[5]) * inv_det,
-        (a[3] * a[7] - a[4] * a[6]) * inv_det,
-        (a[1] * a[6] - a[0] * a[7]) * inv_det,
-        (a[0] * a[4] - a[1] * a[3]) * inv_det
-      ])
-    end
-
-    def transpose
-      Mat3.new([
-        @data[0], @data[3], @data[6],
-        @data[1], @data[4], @data[7],
-        @data[2], @data[5], @data[8]
-      ])
-    end
-
-    def adjoint
-      a = @data
-      Mat3.new([
-        a[4] * a[8] - a[5] * a[7],
-        a[2] * a[7] - a[1] * a[8],
-        a[1] * a[5] - a[2] * a[4],
-        a[5] * a[6] - a[3] * a[8],
-        a[0] * a[8] - a[2] * a[6],
-        a[2] * a[3] - a[0] * a[5],
-        a[3] * a[7] - a[4] * a[6],
-        a[1] * a[6] - a[0] * a[7],
-        a[0] * a[4] - a[1] * a[3]
-      ])
-    end
-
-    def frobenius_norm
-      Math.sqrt(@data.sum { |v| v * v })
-    end
-
-    def translate(x, y)
-      a = @data
-      Mat3.new([
-        a[0], a[1], a[2],
-        a[3], a[4], a[5],
-        x * a[0] + y * a[3] + a[6],
-        x * a[1] + y * a[4] + a[7],
-        x * a[2] + y * a[5] + a[8]
-      ])
-    end
-
-    def rotate(radians)
-      self * Mat3.rotation(radians)
-    end
-
-    def scale(x, y)
-      a = @data
-      Mat3.new([
-        a[0] * x, a[1] * x, a[2] * x,
-        a[3] * y, a[4] * y, a[5] * y,
-        a[6], a[7], a[8]
-      ])
-    end
-
-    def to_a
-      @data.dup
-    end
-
-    def ==(other)
-      return false unless other.is_a?(Mat3)
-
-      @data == other.data
-    end
-
-    def near?(other, epsilon = 1e-6)
-      @data.zip(other.data).all? { |a, b| (a - b).abs < epsilon }
-    end
-
-    def inspect
-      "Mat3[\n" \
-      "  #{@data[0..2].map { |v| format('%8.4f', v) }.join(', ')}\n" \
-      "  #{@data[3..5].map { |v| format('%8.4f', v) }.join(', ')}\n" \
-      "  #{@data[6..8].map { |v| format('%8.4f', v) }.join(', ')}\n]"
-    end
-
-    alias to_s inspect
-  end
-end