larb 0.1.0 → 1.0.1

data/test/larb/vec4_test.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class Vec4Test < Test::Unit::TestCase
+  def test_new_with_default_values
+    v = Larb::Vec4.new
+    assert_equal 0.0, v.x
+    assert_equal 0.0, v.y
+    assert_equal 0.0, v.z
+    assert_equal 1.0, v.w
+  end
+
+  def test_new_with_given_values
+    v = Larb::Vec4.new(1, 2, 3, 4)
+    assert_equal 1.0, v.x
+    assert_equal 2.0, v.y
+    assert_equal 3.0, v.z
+    assert_equal 4.0, v.w
+  end
+
+  def test_bracket_syntax
+    v = Larb::Vec4[1, 2, 3, 4]
+    assert_equal 1.0, v.x
+    assert_equal 2.0, v.y
+    assert_equal 3.0, v.z
+    assert_equal 4.0, v.w
+  end
+
+  def test_bracket_syntax_default_w
+    v = Larb::Vec4[1, 2, 3]
+    assert_equal 1.0, v.w
+  end
+
+  def test_zero
+    assert_equal Larb::Vec4.new(0, 0, 0, 0), Larb::Vec4.zero
+  end
+
+  def test_one
+    assert_equal Larb::Vec4.new(1, 1, 1, 1), Larb::Vec4.one
+  end
+
+  def test_add
+    v1 = Larb::Vec4.new(1, 2, 3, 4)
+    v2 = Larb::Vec4.new(5, 6, 7, 8)
+    assert_equal Larb::Vec4.new(6, 8, 10, 12), v1 + v2
+  end
+
+  def test_subtract
+    v1 = Larb::Vec4.new(5, 6, 7, 8)
+    v2 = Larb::Vec4.new(1, 2, 3, 4)
+    assert_equal Larb::Vec4.new(4, 4, 4, 4), v1 - v2
+  end
+
+  def test_multiply_by_scalar
+    v = Larb::Vec4.new(1, 2, 3, 4)
+    assert_equal Larb::Vec4.new(2, 4, 6, 8), v * 2
+  end
+
+  def test_divide_by_scalar
+    v = Larb::Vec4.new(2, 4, 6, 8)
+    assert_equal Larb::Vec4.new(1, 2, 3, 4), v / 2
+  end
+
+  def test_perspective_divide
+    v = Larb::Vec4.new(2, 4, 6, 2)
+    result = v.perspective_divide
+    assert_instance_of Larb::Vec3, result
+    assert_equal 1.0, result.x
+    assert_equal 2.0, result.y
+    assert_equal 3.0, result.z
+  end
+
+  def test_perspective_divide_w_is_1
+    v = Larb::Vec4.new(1, 2, 3, 1)
+    assert_equal Larb::Vec3.new(1, 2, 3), v.perspective_divide
+  end
+
+  def test_perspective_divide_w_is_0
+    v = Larb::Vec4.new(1, 2, 3, 0)
+    assert_raise(ArgumentError) { v.perspective_divide }
+    assert_equal Larb::Vec3.new(1, 2, 3), v.xyz
+  end
+
+  def test_perspective_divide_rejects_nonfinite_w
+    [Float::NAN, Float::INFINITY].each do |w|
+      assert_raise(ArgumentError) { Larb::Vec4.new(1, 2, 3, w).perspective_divide }
+    end
+  end
+
+  def test_xyz
+    v = Larb::Vec4.new(1, 2, 3, 4)
+    result = v.xyz
+    assert_instance_of Larb::Vec3, result
+    assert_equal Larb::Vec3.new(1, 2, 3), result
+  end
+
+  def test_xy
+    v = Larb::Vec4.new(1, 2, 3, 4)
+    result = v.xy
+    assert_instance_of Larb::Vec2, result
+    assert_equal Larb::Vec2.new(1, 2), result
+  end
+
+  def test_rgb
+    v = Larb::Vec4.new(0.5, 0.6, 0.7, 1.0)
+    result = v.rgb
+    assert_instance_of Larb::Vec3, result
+    assert_equal Larb::Vec3.new(0.5, 0.6, 0.7), result
+  end
+
+  def test_to_a
+    v = Larb::Vec4.new(1, 2, 3, 4)
+    assert_equal [1.0, 2.0, 3.0, 4.0], v.to_a
+  end
+
+  def test_index_access
+    v = Larb::Vec4.new(1, 2, 3, 4)
+    assert_equal 1.0, v[0]
+    assert_equal 2.0, v[1]
+    assert_equal 3.0, v[2]
+    assert_equal 4.0, v[3]
+  end
+
+  def test_negate
+    v = Larb::Vec4.new(1, -2, 3, -4)
+    assert_equal Larb::Vec4.new(-1, 2, -3, 4), -v
+  end
+
+  def test_dot
+    v1 = Larb::Vec4.new(1, 2, 3, 4)
+    v2 = Larb::Vec4.new(5, 6, 7, 8)
+    assert_equal 70.0, v1.dot(v2)
+  end
+
+  def test_length
+    v = Larb::Vec4.new(1, 2, 2, 0)
+    assert_equal 3.0, v.length
+  end
+
+  def test_length_squared
+    v = Larb::Vec4.new(1, 2, 2, 0)
+    assert_equal 9.0, v.length_squared
+  end
+
+  def test_normalize
+    v = Larb::Vec4.new(1, 2, 2, 0)
+    result = v.normalize
+    assert_in_delta 1.0, result.length, 1e-10
+  end
+
+  def test_normalize!
+    v = Larb::Vec4.new(1, 2, 2, 0)
+    v.normalize!
+    assert_in_delta 1.0, v.length, 1e-10
+  end
+
+  def test_equality
+    v1 = Larb::Vec4.new(1, 2, 3, 4)
+    v2 = Larb::Vec4.new(1, 2, 3, 4)
+    assert_equal v1, v2
+  end
+
+  def test_inequality
+    v1 = Larb::Vec4.new(1, 2, 3, 4)
+    v2 = Larb::Vec4.new(1, 2, 3, 5)
+    assert_not_equal v1, v2
+  end
+
+  def test_not_equal_to_array
+    v = Larb::Vec4.new(1, 2, 3, 4)
+    assert_not_equal v, [1, 2, 3, 4]
+  end
+
+  def test_near
+    v1 = Larb::Vec4.new(1.0, 2.0, 3.0, 4.0)
+    v2 = Larb::Vec4.new(1.0000001, 2.0000001, 3.0000001, 4.0000001)
+    assert v1.near?(v2)
+  end
+
+  def test_lerp
+    v1 = Larb::Vec4.new(0, 0, 0, 0)
+    v2 = Larb::Vec4.new(10, 20, 30, 40)
+    assert_equal Larb::Vec4.new(5, 10, 15, 20), v1.lerp(v2, 0.5)
+  end
+
+  def test_inspect
+    v = Larb::Vec4.new(1, 2, 3, 4)
+    assert_equal "Vec4[1.0, 2.0, 3.0, 4.0]", v.inspect
+  end
+
+  def test_to_s
+    v = Larb::Vec4.new(1, 2, 3, 4)
+    assert_equal v.inspect, v.to_s
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "test-unit"
+require_relative "../lib/larb"

metadata

@@ -1,43 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: larb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Yudai Takada
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 description: Larb provides vectors, matrices, quaternions, and Color classes for 2D/3D
   graphics and mathematical computations
 email:
 - t.yudai92@gmail.com
 executables: []
-extensions: []
+extensions:
+- ext/larb/extconf.rb
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - LICENSE
 - README.md
-- Rakefile
+- ext/larb/color.c
+- ext/larb/color.h
+- ext/larb/extconf.rb
+- ext/larb/larb.c
+- ext/larb/larb.h
+- ext/larb/mat2.c
+- ext/larb/mat2.h
+- ext/larb/mat2d.c
+- ext/larb/mat2d.h
+- ext/larb/mat3.c
+- ext/larb/mat3.h
+- ext/larb/mat4.c
+- ext/larb/mat4.h
+- ext/larb/matrix_utils.h
+- ext/larb/quat.c
+- ext/larb/quat.h
+- ext/larb/quat2.c
+- ext/larb/quat2.h
+- ext/larb/vec2.c
+- ext/larb/vec2.h
+- ext/larb/vec3.c
+- ext/larb/vec3.h
+- ext/larb/vec4.c
+- ext/larb/vec4.h
 - lib/larb.rb
-- lib/larb/color.rb
-- lib/larb/mat2.rb
-- lib/larb/mat2d.rb
-- lib/larb/mat3.rb
-- lib/larb/mat4.rb
-- lib/larb/quat.rb
-- lib/larb/quat2.rb
-- lib/larb/vec2.rb
-- lib/larb/vec3.rb
-- lib/larb/vec4.rb
-homepage: https://github.com/ydah/larb
+- lib/larb/version.rb
+- test/larb/color_test.rb
+- test/larb/mat2_test.rb
+- test/larb/mat2d_test.rb
+- test/larb/mat3_test.rb
+- test/larb/mat4_test.rb
+- test/larb/matrix_test.rb
+- test/larb/native_value_test.rb
+- test/larb/quat2_test.rb
+- test/larb/quat_test.rb
+- test/larb/vec2_test.rb
+- test/larb/vec3_test.rb
+- test/larb/vec4_test.rb
+- test/test_helper.rb
+homepage: https://github.com/rbgfx/larb
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/ydah/larb
-  changelog_uri: https://github.com/ydah/larb/blob/main/CHANGELOG.md
+  source_code_uri: https://github.com/rbgfx/larb
+  changelog_uri: https://github.com/rbgfx/larb/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -52,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.19
 specification_version: 4
 summary: Linear algebra library for 2D/3D graphics in Ruby
 test_files: []

data/Rakefile

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

@@ -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