larb 0.1.0 → 1.0.0

data/lib/larb/quat2.rb

@@ -1,193 +0,0 @@
-# frozen_string_literal: true
-
-module Larb
-  # Dual Quaternion for rigid body transformations
-  # Represented as 8 values: [real quaternion (4), dual quaternion (4)]
-  # real: rotation, dual: translation encoded
-  class Quat2
-    attr_reader :data
-
-    def initialize(data = nil)
-      @data = data || [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0]
-    end
-
-    def self.identity
-      new
-    end
-
-    def self.from_rotation_translation(rotation, translation)
-      rx, ry, rz, rw = rotation.x, rotation.y, rotation.z, rotation.w
-      tx, ty, tz = translation.x, translation.y, translation.z
-
-      new([
-        rx, ry, rz, rw,
-        (tx * rw + ty * rz - tz * ry) * 0.5,
-        (ty * rw + tz * rx - tx * rz) * 0.5,
-        (tz * rw + tx * ry - ty * rx) * 0.5,
-        (-tx * rx - ty * ry - tz * rz) * 0.5
-      ])
-    end
-
-    def self.from_translation(translation)
-      from_rotation_translation(Quat.identity, translation)
-    end
-
-    def self.from_rotation(rotation)
-      new([rotation.x, rotation.y, rotation.z, rotation.w, 0, 0, 0, 0])
-    end
-
-    def self.from_mat4(m)
-      rotation = m.extract_rotation
-      translation = m.extract_translation
-      from_rotation_translation(rotation, translation)
-    end
-
-    def real
-      Quat.new(@data[0], @data[1], @data[2], @data[3])
-    end
-
-    def dual
-      Quat.new(@data[4], @data[5], @data[6], @data[7])
-    end
-
-    def [](i)
-      @data[i]
-    end
-
-    def []=(i, v)
-      @data[i] = v.to_f
-    end
-
-    def *(other)
-      case other
-      when Quat2
-        ax0, ay0, az0, aw0 = @data[0], @data[1], @data[2], @data[3]
-        bx1, by1, bz1, bw1 = @data[4], @data[5], @data[6], @data[7]
-        ax1, ay1, az1, aw1 = other.data[0], other.data[1], other.data[2], other.data[3]
-        bx0, by0, bz0, bw0 = other.data[4], other.data[5], other.data[6], other.data[7]
-
-        Quat2.new([
-          ax0 * aw1 + aw0 * ax1 + ay0 * az1 - az0 * ay1,
-          ay0 * aw1 + aw0 * ay1 + az0 * ax1 - ax0 * az1,
-          az0 * aw1 + aw0 * az1 + ax0 * ay1 - ay0 * ax1,
-          aw0 * aw1 - ax0 * ax1 - ay0 * ay1 - az0 * az1,
-          ax0 * bw0 + aw0 * bx0 + ay0 * bz0 - az0 * by0 +
-            bx1 * aw1 + bw1 * ax1 + by1 * az1 - bz1 * ay1,
-          ay0 * bw0 + aw0 * by0 + az0 * bx0 - ax0 * bz0 +
-            by1 * aw1 + bw1 * ay1 + bz1 * ax1 - bx1 * az1,
-          az0 * bw0 + aw0 * bz0 + ax0 * by0 - ay0 * bx0 +
-            bz1 * aw1 + bw1 * az1 + bx1 * ay1 - by1 * ax1,
-          aw0 * bw0 - ax0 * bx0 - ay0 * by0 - az0 * bz0 +
-            bw1 * aw1 - bx1 * ax1 - by1 * ay1 - bz1 * az1
-        ])
-      when Vec3
-        transform_point(other)
-      when Numeric
-        Quat2.new(@data.map { |v| v * other })
-      end
-    end
-
-    def +(other)
-      Quat2.new(@data.zip(other.data).map { |a, b| a + b })
-    end
-
-    def -(other)
-      Quat2.new(@data.zip(other.data).map { |a, b| a - b })
-    end
-
-    def dot(other)
-      @data[0] * other.data[0] + @data[1] * other.data[1] +
-        @data[2] * other.data[2] + @data[3] * other.data[3]
-    end
-
-    def length
-      Math.sqrt(length_squared)
-    end
-
-    def length_squared
-      @data[0..3].sum { |v| v * v }
-    end
-
-    def normalize
-      len = length
-      return Quat2.new(@data.dup) if len < 1e-10
-
-      inv_len = 1.0 / len
-      Quat2.new(@data.map { |v| v * inv_len })
-    end
-
-    def normalize!
-      len = length
-      return self if len < 1e-10
-
-      inv_len = 1.0 / len
-      @data.map! { |v| v * inv_len }
-      self
-    end
-
-    def conjugate
-      Quat2.new([
-        -@data[0], -@data[1], -@data[2], @data[3],
-        -@data[4], -@data[5], -@data[6], @data[7]
-      ])
-    end
-
-    def inverse
-      len_sq = length_squared
-      return conjugate if len_sq < 1e-10
-
-      inv_len_sq = 1.0 / len_sq
-      conj = conjugate
-      Quat2.new(conj.data.map { |v| v * inv_len_sq })
-    end
-
-    def translation
-      ax, ay, az, aw = @data[0], @data[1], @data[2], @data[3]
-      bx, by, bz, bw = @data[4], @data[5], @data[6], @data[7]
-      # t = 2 * dual * conjugate(real)
-      Vec3.new(
-        2 * (-bw * ax + bx * aw - by * az + bz * ay),
-        2 * (-bw * ay + by * aw - bz * ax + bx * az),
-        2 * (-bw * az + bz * aw - bx * ay + by * ax)
-      )
-    end
-
-    def rotation
-      real.normalize
-    end
-
-    def transform_point(point)
-      rotation * point + translation
-    end
-
-    def lerp(other, t)
-      Quat2.new(@data.zip(other.data).map { |a, b| a + (b - a) * t }).normalize
-    end
-
-    def to_mat4
-      rot = rotation
-      trans = translation
-      Mat4.from_quaternion(rot) * Mat4.translation(trans.x, trans.y, trans.z)
-    end
-
-    def to_a
-      @data.dup
-    end
-
-    def ==(other)
-      return false unless other.is_a?(Quat2)
-
-      @data == other.data
-    end
-
-    def near?(other, epsilon = 1e-6)
-      @data.zip(other.data).all? { |a, b| (a - b).abs < epsilon }
-    end
-
-    def inspect
-      "Quat2[real: #{real.inspect}, dual: #{dual.inspect}]"
-    end
-
-    alias to_s inspect
-  end
-end

data/lib/larb/vec2.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-module Larb
-  class Vec2
-    attr_accessor :x, :y
-
-    def initialize(x = 0.0, y = 0.0)
-      @x = x.to_f
-      @y = y.to_f
-    end
-
-    def self.[](x, y)
-      new(x, y)
-    end
-
-    def self.zero
-      new(0, 0)
-    end
-
-    def self.one
-      new(1, 1)
-    end
-
-    def +(other)
-      Vec2.new(@x + other.x, @y + other.y)
-    end
-
-    def -(other)
-      Vec2.new(@x - other.x, @y - other.y)
-    end
-
-    def *(scalar)
-      Vec2.new(@x * scalar, @y * scalar)
-    end
-
-    def /(scalar)
-      Vec2.new(@x / scalar, @y / scalar)
-    end
-
-    def -@
-      Vec2.new(-@x, -@y)
-    end
-
-    def dot(other)
-      @x * other.x + @y * other.y
-    end
-
-    def length
-      Math.sqrt(@x * @x + @y * @y)
-    end
-
-    def length_squared
-      @x * @x + @y * @y
-    end
-
-    def normalize
-      self / length
-    end
-
-    def normalize!
-      l = length
-      @x /= l
-      @y /= l
-      self
-    end
-
-    def lerp(other, t)
-      self + (other - self) * t
-    end
-
-    def to_a
-      [@x, @y]
-    end
-
-    def [](i)
-      to_a[i]
-    end
-
-    def []=(i, v)
-      if i == 0
-        @x = v
-      else
-        @y = v
-      end
-    end
-
-    def ==(other)
-      return false unless other.is_a?(Vec2)
-
-      @x == other.x && @y == other.y
-    end
-
-    def near?(other, epsilon = 1e-6)
-      (@x - other.x).abs < epsilon && (@y - other.y).abs < epsilon
-    end
-
-    def angle
-      Math.atan2(@y, @x)
-    end
-
-    def angle_to(other)
-      Math.atan2(other.y - @y, other.x - @x)
-    end
-
-    def rotate(radians)
-      c = Math.cos(radians)
-      s = Math.sin(radians)
-      Vec2.new(@x * c - @y * s, @x * s + @y * c)
-    end
-
-    def distance(other)
-      Math.sqrt(distance_squared(other))
-    end
-
-    def distance_squared(other)
-      dx = @x - other.x
-      dy = @y - other.y
-      dx * dx + dy * dy
-    end
-
-    def cross(other)
-      @x * other.y - @y * other.x
-    end
-
-    def perpendicular
-      Vec2.new(-@y, @x)
-    end
-
-    def reflect(normal)
-      self - normal * (2 * dot(normal))
-    end
-
-    def clamp_length(max_length)
-      len_sq = length_squared
-      return self if len_sq <= max_length * max_length
-
-      self * (max_length / Math.sqrt(len_sq))
-    end
-
-    def to_vec3(z = 0.0)
-      Vec3.new(@x, @y, z)
-    end
-
-    def inspect
-      "Vec2[#{@x}, #{@y}]"
-    end
-
-    alias to_s inspect
-  end
-end

data/lib/larb/vec3.rb

@@ -1,218 +0,0 @@
-# frozen_string_literal: true
-
-module Larb
-  class Vec3
-    attr_accessor :x, :y, :z
-
-    def initialize(x = 0.0, y = 0.0, z = 0.0)
-      @x = x.to_f
-      @y = y.to_f
-      @z = z.to_f
-    end
-
-    def self.[](x, y, z)
-      new(x, y, z)
-    end
-
-    def self.zero
-      new(0, 0, 0)
-    end
-
-    def self.one
-      new(1, 1, 1)
-    end
-
-    def self.up
-      new(0, 1, 0)
-    end
-
-    def self.down
-      new(0, -1, 0)
-    end
-
-    def self.forward
-      new(0, 0, -1)
-    end
-
-    def self.back
-      new(0, 0, 1)
-    end
-
-    def self.right
-      new(1, 0, 0)
-    end
-
-    def self.left
-      new(-1, 0, 0)
-    end
-
-    def +(other)
-      Vec3.new(@x + other.x, @y + other.y, @z + other.z)
-    end
-
-    def -(other)
-      Vec3.new(@x - other.x, @y - other.y, @z - other.z)
-    end
-
-    def *(scalar)
-      case scalar
-      when Numeric
-        Vec3.new(@x * scalar, @y * scalar, @z * scalar)
-      when Vec3
-        Vec3.new(@x * scalar.x, @y * scalar.y, @z * scalar.z)
-      end
-    end
-
-    def /(scalar)
-      Vec3.new(@x / scalar, @y / scalar, @z / scalar)
-    end
-
-    def -@
-      Vec3.new(-@x, -@y, -@z)
-    end
-
-    def dot(other)
-      @x * other.x + @y * other.y + @z * other.z
-    end
-
-    def cross(other)
-      Vec3.new(
-        @y * other.z - @z * other.y,
-        @z * other.x - @x * other.z,
-        @x * other.y - @y * other.x
-      )
-    end
-
-    def length
-      Math.sqrt(@x * @x + @y * @y + @z * @z)
-    end
-
-    def length_squared
-      @x * @x + @y * @y + @z * @z
-    end
-
-    def normalize
-      self / length
-    end
-
-    def reflect(normal)
-      self - normal * (2 * dot(normal))
-    end
-
-    def xy
-      Vec2.new(@x, @y)
-    end
-
-    def xz
-      Vec2.new(@x, @z)
-    end
-
-    def yz
-      Vec2.new(@y, @z)
-    end
-
-    def lerp(other, t)
-      self + (other - self) * t
-    end
-
-    def to_a
-      [@x, @y, @z]
-    end
-
-    def to_vec4(w = 1.0)
-      Vec4.new(@x, @y, @z, w)
-    end
-
-    def [](i)
-      to_a[i]
-    end
-
-    def ==(other)
-      return false unless other.is_a?(Vec3)
-
-      @x == other.x && @y == other.y && @z == other.z
-    end
-
-    def near?(other, epsilon = 1e-6)
-      (@x - other.x).abs < epsilon &&
-        (@y - other.y).abs < epsilon &&
-        (@z - other.z).abs < epsilon
-    end
-
-    def distance(other)
-      Math.sqrt(distance_squared(other))
-    end
-
-    def distance_squared(other)
-      dx = @x - other.x
-      dy = @y - other.y
-      dz = @z - other.z
-      dx * dx + dy * dy + dz * dz
-    end
-
-    def angle_between(other)
-      d = dot(other) / (length * other.length)
-      Math.acos(d.clamp(-1.0, 1.0))
-    end
-
-    def project(onto)
-      onto * (dot(onto) / onto.length_squared)
-    end
-
-    def reject(from)
-      self - project(from)
-    end
-
-    def slerp(other, t)
-      dot_val = normalize.dot(other.normalize).clamp(-1.0, 1.0)
-      theta = Math.acos(dot_val) * t
-      relative = (other - self * dot_val).normalize
-      self * Math.cos(theta) + relative * Math.sin(theta)
-    end
-
-    def clamp_length(max_length)
-      len_sq = length_squared
-      return self if len_sq <= max_length * max_length
-
-      self * (max_length / Math.sqrt(len_sq))
-    end
-
-    def normalize!
-      l = length
-      @x /= l
-      @y /= l
-      @z /= l
-      self
-    end
-
-    def min(other)
-      Vec3.new([@x, other.x].min, [@y, other.y].min, [@z, other.z].min)
-    end
-
-    def max(other)
-      Vec3.new([@x, other.x].max, [@y, other.y].max, [@z, other.z].max)
-    end
-
-    def abs
-      Vec3.new(@x.abs, @y.abs, @z.abs)
-    end
-
-    def floor
-      Vec3.new(@x.floor, @y.floor, @z.floor)
-    end
-
-    def ceil
-      Vec3.new(@x.ceil, @y.ceil, @z.ceil)
-    end
-
-    def round
-      Vec3.new(@x.round, @y.round, @z.round)
-    end
-
-    def inspect
-      "Vec3[#{@x}, #{@y}, #{@z}]"
-    end
-
-    alias to_s inspect
-  end
-end

data/lib/larb/vec4.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module Larb
-  class Vec4
-    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 = 1.0)
-      new(x, y, z, w)
-    end
-
-    def self.zero
-      new(0, 0, 0, 0)
-    end
-
-    def self.one
-      new(1, 1, 1, 1)
-    end
-
-    def +(other)
-      Vec4.new(@x + other.x, @y + other.y, @z + other.z, @w + other.w)
-    end
-
-    def -(other)
-      Vec4.new(@x - other.x, @y - other.y, @z - other.z, @w - other.w)
-    end
-
-    def *(scalar)
-      Vec4.new(@x * scalar, @y * scalar, @z * scalar, @w * scalar)
-    end
-
-    def /(scalar)
-      Vec4.new(@x / scalar, @y / scalar, @z / scalar, @w / scalar)
-    end
-
-    def -@
-      Vec4.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
-      self / length
-    end
-
-    def normalize!
-      l = length
-      @x /= l
-      @y /= l
-      @z /= l
-      @w /= l
-      self
-    end
-
-    def perspective_divide
-      return Vec3.new(@x, @y, @z) if @w == 0 || @w == 1
-
-      Vec3.new(@x / @w, @y / @w, @z / @w)
-    end
-
-    def xyz
-      Vec3.new(@x, @y, @z)
-    end
-
-    def xy
-      Vec2.new(@x, @y)
-    end
-
-    def rgb
-      Vec3.new(@x, @y, @z)
-    end
-
-    def to_a
-      [@x, @y, @z, @w]
-    end
-
-    def [](i)
-      to_a[i]
-    end
-
-    def ==(other)
-      return false unless other.is_a?(Vec4)
-
-      @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 lerp(other, t)
-      Vec4.new(
-        @x + (other.x - @x) * t,
-        @y + (other.y - @y) * t,
-        @z + (other.z - @z) * t,
-        @w + (other.w - @w) * t
-      )
-    end
-
-    def inspect
-      "Vec4[#{@x}, #{@y}, #{@z}, #{@w}]"
-    end
-
-    alias to_s inspect
-  end
-end