3rb 0.1.0

data/lib/3rb/math/vector3.rb

@@ -0,0 +1,366 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class Vector3
+    attr_accessor :x, :y, :z
+
+    def initialize(x = 0, y = 0, z = 0)
+      @x = x.to_f
+      @y = y.to_f
+      @z = z.to_f
+    end
+
+    def set(x, y, z)
+      @x = x.to_f
+      @y = y.to_f
+      @z = z.to_f
+      self
+    end
+
+    def set_scalar(scalar)
+      @x = @y = @z = scalar.to_f
+      self
+    end
+
+    def copy(v)
+      @x = v.x
+      @y = v.y
+      @z = v.z
+      self
+    end
+
+    def clone
+      Vector3.new(@x, @y, @z)
+    end
+
+    def +(other)
+      Vector3.new(@x + other.x, @y + other.y, @z + other.z)
+    end
+
+    def -(other)
+      Vector3.new(@x - other.x, @y - other.y, @z - other.z)
+    end
+
+    def *(scalar)
+      Vector3.new(@x * scalar, @y * scalar, @z * scalar)
+    end
+
+    def /(scalar)
+      Vector3.new(@x / scalar, @y / scalar, @z / scalar)
+    end
+
+    def -@
+      Vector3.new(-@x, -@y, -@z)
+    end
+
+    def add!(other)
+      @x += other.x
+      @y += other.y
+      @z += other.z
+      self
+    end
+
+    def sub!(other)
+      @x -= other.x
+      @y -= other.y
+      @z -= other.z
+      self
+    end
+
+    alias sub sub!
+
+    def add(other)
+      add!(other)
+    end
+
+    def multiply_scalar(scalar)
+      multiply_scalar!(scalar)
+    end
+
+    def multiply_scalar!(scalar)
+      @x *= scalar
+      @y *= scalar
+      @z *= scalar
+      self
+    end
+
+    def divide_scalar!(scalar)
+      @x /= scalar
+      @y /= scalar
+      @z /= scalar
+      self
+    end
+
+    def dot(other)
+      @x * other.x + @y * other.y + @z * other.z
+    end
+
+    def cross(other)
+      Vector3.new(
+        @y * other.z - @z * other.y,
+        @z * other.x - @x * other.z,
+        @x * other.y - @y * other.x
+      )
+    end
+
+    def cross!(other)
+      x = @y * other.z - @z * other.y
+      y = @z * other.x - @x * other.z
+      z = @x * other.y - @y * other.x
+      @x = x
+      @y = y
+      @z = z
+      self
+    end
+
+    def length_sq
+      @x * @x + @y * @y + @z * @z
+    end
+
+    def length
+      Math.sqrt(length_sq)
+    end
+
+    def normalize
+      clone.normalize!
+    end
+
+    def normalize!
+      len = length
+      return self if len.zero?
+
+      divide_scalar!(len)
+    end
+
+    def distance_to(other)
+      (self - other).length
+    end
+
+    def distance_to_sq(other)
+      (self - other).length_sq
+    end
+
+    def lerp(other, alpha)
+      Vector3.new(
+        @x + (other.x - @x) * alpha,
+        @y + (other.y - @y) * alpha,
+        @z + (other.z - @z) * alpha
+      )
+    end
+
+    def lerp!(other, alpha)
+      @x += (other.x - @x) * alpha
+      @y += (other.y - @y) * alpha
+      @z += (other.z - @z) * alpha
+      self
+    end
+
+    def negate!
+      @x = -@x
+      @y = -@y
+      @z = -@z
+      self
+    end
+
+    def min(other)
+      Vector3.new(
+        [@x, other.x].min,
+        [@y, other.y].min,
+        [@z, other.z].min
+      )
+    end
+
+    def max(other)
+      Vector3.new(
+        [@x, other.x].max,
+        [@y, other.y].max,
+        [@z, other.z].max
+      )
+    end
+
+    def clamp(min_vec, max_vec)
+      Vector3.new(
+        [[@x, min_vec.x].max, max_vec.x].min,
+        [[@y, min_vec.y].max, max_vec.y].min,
+        [[@z, min_vec.z].max, max_vec.z].min
+      )
+    end
+
+    def floor
+      Vector3.new(@x.floor, @y.floor, @z.floor)
+    end
+
+    def ceil
+      Vector3.new(@x.ceil, @y.ceil, @z.ceil)
+    end
+
+    def round
+      Vector3.new(@x.round, @y.round, @z.round)
+    end
+
+    def angle_to(other)
+      denominator = Math.sqrt(length_sq * other.length_sq)
+      return Math::PI / 2 if denominator.zero?
+
+      theta = dot(other) / denominator
+      Math.acos([[-1, theta].max, 1].min)
+    end
+
+    def project_on_vector(other)
+      denominator = other.length_sq
+      return Vector3.new if denominator.zero?
+
+      scalar = other.dot(self) / denominator
+      other * scalar
+    end
+
+    def reflect(normal)
+      self - normal * 2 * dot(normal)
+    end
+
+    def apply_matrix3(m)
+      x = @x
+      y = @y
+      z = @z
+      e = m.elements
+
+      Vector3.new(
+        e[0] * x + e[3] * y + e[6] * z,
+        e[1] * x + e[4] * y + e[7] * z,
+        e[2] * x + e[5] * y + e[8] * z
+      )
+    end
+
+    def apply_matrix4(m)
+      x = @x
+      y = @y
+      z = @z
+      e = m.elements
+
+      w = 1.0 / (e[3] * x + e[7] * y + e[11] * z + e[15])
+
+      Vector3.new(
+        (e[0] * x + e[4] * y + e[8] * z + e[12]) * w,
+        (e[1] * x + e[5] * y + e[9] * z + e[13]) * w,
+        (e[2] * x + e[6] * y + e[10] * z + e[14]) * w
+      )
+    end
+
+    def set_from_spherical(s)
+      sin_phi_radius = Math.sin(s.phi) * s.radius
+      @x = sin_phi_radius * Math.sin(s.theta)
+      @y = Math.cos(s.phi) * s.radius
+      @z = sin_phi_radius * Math.cos(s.theta)
+      self
+    end
+
+    def set_from_matrix_column(matrix, index)
+      from_array(matrix.elements, index * 4)
+    end
+
+    def from_array(array, offset = 0)
+      @x = array[offset].to_f
+      @y = array[offset + 1].to_f
+      @z = array[offset + 2].to_f
+      self
+    end
+
+    def cross_vectors(a, b)
+      @x = a.y * b.z - a.z * b.y
+      @y = a.z * b.x - a.x * b.z
+      @z = a.x * b.y - a.y * b.x
+      self
+    end
+
+    def set_from_matrix_position(m)
+      e = m.elements
+      @x = e[12]
+      @y = e[13]
+      @z = e[14]
+      self
+    end
+
+    def apply_quaternion(q)
+      x = @x
+      y = @y
+      z = @z
+      qx = q.x
+      qy = q.y
+      qz = q.z
+      qw = q.w
+
+      ix = qw * x + qy * z - qz * y
+      iy = qw * y + qz * x - qx * z
+      iz = qw * z + qx * y - qy * x
+      iw = -qx * x - qy * y - qz * z
+
+      Vector3.new(
+        ix * qw + iw * -qx + iy * -qz - iz * -qy,
+        iy * qw + iw * -qy + iz * -qx - ix * -qz,
+        iz * qw + iw * -qz + ix * -qy - iy * -qx
+      )
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Vector3)
+
+      (@x - other.x).abs < Float::EPSILON &&
+        (@y - other.y).abs < Float::EPSILON &&
+        (@z - other.z).abs < Float::EPSILON
+    end
+
+    def equals?(other, tolerance = Float::EPSILON)
+      return false unless other.is_a?(Vector3)
+
+      (@x - other.x).abs <= tolerance &&
+        (@y - other.y).abs <= tolerance &&
+        (@z - other.z).abs <= tolerance
+    end
+
+    def to_a
+      [@x, @y, @z]
+    end
+
+    def to_h
+      { x: @x, y: @y, z: @z }
+    end
+
+    def inspect
+      "#<Sunrb::Vector3 x=#{@x} y=#{@y} z=#{@z}>"
+    end
+
+    class << self
+      def zero
+        new(0, 0, 0)
+      end
+
+      def one
+        new(1, 1, 1)
+      end
+
+      def up
+        new(0, 1, 0)
+      end
+
+      def down
+        new(0, -1, 0)
+      end
+
+      def forward
+        new(0, 0, -1)
+      end
+
+      def back
+        new(0, 0, 1)
+      end
+
+      def left
+        new(-1, 0, 0)
+      end
+
+      def right
+        new(1, 0, 0)
+      end
+    end
+  end
+end

data/lib/3rb/math/vector4.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class Vector4
+    attr_accessor :x, :y, :z, :w
+
+    def initialize(x = 0, y = 0, z = 0, w = 1)
+      @x = x.to_f
+      @y = y.to_f
+      @z = z.to_f
+      @w = w.to_f
+    end
+
+    def set(x, y, z, w)
+      @x = x.to_f
+      @y = y.to_f
+      @z = z.to_f
+      @w = w.to_f
+      self
+    end
+
+    def set_scalar(scalar)
+      @x = @y = @z = @w = scalar.to_f
+      self
+    end
+
+    def copy(v)
+      @x = v.x
+      @y = v.y
+      @z = v.z
+      @w = v.respond_to?(:w) ? v.w : 1.0
+      self
+    end
+
+    def clone
+      Vector4.new(@x, @y, @z, @w)
+    end
+
+    def +(other)
+      Vector4.new(@x + other.x, @y + other.y, @z + other.z, @w + other.w)
+    end
+
+    def -(other)
+      Vector4.new(@x - other.x, @y - other.y, @z - other.z, @w - other.w)
+    end
+
+    def *(scalar)
+      Vector4.new(@x * scalar, @y * scalar, @z * scalar, @w * scalar)
+    end
+
+    def /(scalar)
+      Vector4.new(@x / scalar, @y / scalar, @z / scalar, @w / scalar)
+    end
+
+    def -@
+      Vector4.new(-@x, -@y, -@z, -@w)
+    end
+
+    def add!(other)
+      @x += other.x
+      @y += other.y
+      @z += other.z
+      @w += other.w
+      self
+    end
+
+    def sub!(other)
+      @x -= other.x
+      @y -= other.y
+      @z -= other.z
+      @w -= other.w
+      self
+    end
+
+    def multiply_scalar!(scalar)
+      @x *= scalar
+      @y *= scalar
+      @z *= scalar
+      @w *= scalar
+      self
+    end
+
+    def divide_scalar!(scalar)
+      @x /= scalar
+      @y /= scalar
+      @z /= scalar
+      @w /= scalar
+      self
+    end
+
+    def dot(other)
+      @x * other.x + @y * other.y + @z * other.z + @w * other.w
+    end
+
+    def length_sq
+      @x * @x + @y * @y + @z * @z + @w * @w
+    end
+
+    def length
+      Math.sqrt(length_sq)
+    end
+
+    def normalize
+      clone.normalize!
+    end
+
+    def normalize!
+      len = length
+      return self if len.zero?
+
+      divide_scalar!(len)
+    end
+
+    def lerp(other, alpha)
+      Vector4.new(
+        @x + (other.x - @x) * alpha,
+        @y + (other.y - @y) * alpha,
+        @z + (other.z - @z) * alpha,
+        @w + (other.w - @w) * alpha
+      )
+    end
+
+    def lerp!(other, alpha)
+      @x += (other.x - @x) * alpha
+      @y += (other.y - @y) * alpha
+      @z += (other.z - @z) * alpha
+      @w += (other.w - @w) * alpha
+      self
+    end
+
+    def negate!
+      @x = -@x
+      @y = -@y
+      @z = -@z
+      @w = -@w
+      self
+    end
+
+    def min(other)
+      Vector4.new(
+        [@x, other.x].min,
+        [@y, other.y].min,
+        [@z, other.z].min,
+        [@w, other.w].min
+      )
+    end
+
+    def max(other)
+      Vector4.new(
+        [@x, other.x].max,
+        [@y, other.y].max,
+        [@z, other.z].max,
+        [@w, other.w].max
+      )
+    end
+
+    def clamp(min_vec, max_vec)
+      Vector4.new(
+        [[@x, min_vec.x].max, max_vec.x].min,
+        [[@y, min_vec.y].max, max_vec.y].min,
+        [[@z, min_vec.z].max, max_vec.z].min,
+        [[@w, min_vec.w].max, max_vec.w].min
+      )
+    end
+
+    def floor
+      Vector4.new(@x.floor, @y.floor, @z.floor, @w.floor)
+    end
+
+    def ceil
+      Vector4.new(@x.ceil, @y.ceil, @z.ceil, @w.ceil)
+    end
+
+    def round
+      Vector4.new(@x.round, @y.round, @z.round, @w.round)
+    end
+
+    def apply_matrix4(m)
+      x = @x
+      y = @y
+      z = @z
+      w = @w
+      e = m.elements
+
+      Vector4.new(
+        e[0] * x + e[4] * y + e[8] * z + e[12] * w,
+        e[1] * x + e[5] * y + e[9] * z + e[13] * w,
+        e[2] * x + e[6] * y + e[10] * z + e[14] * w,
+        e[3] * x + e[7] * y + e[11] * z + e[15] * w
+      )
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Vector4)
+
+      (@x - other.x).abs < Float::EPSILON &&
+        (@y - other.y).abs < Float::EPSILON &&
+        (@z - other.z).abs < Float::EPSILON &&
+        (@w - other.w).abs < Float::EPSILON
+    end
+
+    def equals?(other, tolerance = Float::EPSILON)
+      return false unless other.is_a?(Vector4)
+
+      (@x - other.x).abs <= tolerance &&
+        (@y - other.y).abs <= tolerance &&
+        (@z - other.z).abs <= tolerance &&
+        (@w - other.w).abs <= tolerance
+    end
+
+    def to_a
+      [@x, @y, @z, @w]
+    end
+
+    def to_h
+      { x: @x, y: @y, z: @z, w: @w }
+    end
+
+    def inspect
+      "#<Sunrb::Vector4 x=#{@x} y=#{@y} z=#{@z} w=#{@w}>"
+    end
+
+    class << self
+      def zero
+        new(0, 0, 0, 0)
+      end
+
+      def one
+        new(1, 1, 1, 1)
+      end
+    end
+  end
+end