larb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1ca6912c8989e8917738c9965540ee392fce8e3c5bcfb95960b1e36d39a84b56
+  data.tar.gz: c38e9ab279c3e9ede439d90ff7e9153a523e189e7f5bf18867811c0356b21866
+SHA512:
+  metadata.gz: f3499157dd5c279ba8afac41e9d245742cfd7d6a31bdf83e683ee42d9c448e6b67666b1c28b15becf18640393486658e2825e44b10ded335a37a5eb37858c722
+  data.tar.gz: 381dce0add3519b5b0c2661a443d34aa2cc14dfcbb1225c5b507c744b2fa9cd31d89e7fdfac5a776abf6b924e28aeb08afa66ade9e87b19d7268f0946988b7a9

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## Unreleased
+
+## 0.1.0 - 2026-01-02
+
+- Initial release.

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,63 @@
+# Larb
+
+Linear algebra library for 2D/3D graphics in Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'larb'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install larb
+```
+
+## Usage
+
+```ruby
+require 'larb'
+
+# Vectors
+v2 = Larb::Vec2.new(1, 2)
+v3 = Larb::Vec3.new(1, 2, 3)
+v4 = Larb::Vec4.new(1, 2, 3, 1)
+
+# Vector operations
+sum = v3 + Larb::Vec3.new(4, 5, 6)
+dot = v3.dot(Larb::Vec3.new(1, 0, 0))
+cross = v3.cross(Larb::Vec3.up)
+normalized = v3.normalize
+
+# Matrices
+identity = Larb::Mat4.identity
+translation = Larb::Mat4.translation(10, 20, 30)
+rotation = Larb::Mat4.rotation_y(Math::PI / 4)
+scale = Larb::Mat4.scaling(2, 2, 2)
+
+# Matrix multiplication
+transform = translation * rotation * scale
+transformed_point = transform * v4
+
+# Quaternions
+quat = Larb::Quat.from_axis_angle(Larb::Vec3.up, Math::PI / 2)
+rotated = quat * Larb::Vec3.new(1, 0, 0)
+
+# Colors
+red = Larb::Color.red
+custom = Larb::Color.new(0.5, 0.3, 0.8, 1.0)
+hex_color = Larb::Color.from_hex("#ff8800")
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/lib/larb/color.rb

@@ -0,0 +1,148 @@
+# 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

@@ -0,0 +1,119 @@
+# 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

@@ -0,0 +1,180 @@
+# 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