3rb 0.1.0

data/lib/3rb/math/color.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class Color
+    attr_accessor :r, :g, :b
+
+    def initialize(r = nil, g = nil, b = nil)
+      if r.nil? && g.nil? && b.nil?
+        @r = @g = @b = 1.0
+      elsif g.nil? && b.nil?
+        if r.is_a?(Integer)
+          set_hex(r)
+        elsif r.is_a?(String)
+          set_style(r)
+        elsif r.is_a?(Color)
+          copy(r)
+        else
+          @r = @g = @b = r.to_f
+        end
+      else
+        @r = r.to_f
+        @g = (g || r).to_f
+        @b = (b || r).to_f
+      end
+    end
+
+    def set(r, g = nil, b = nil)
+      if g.nil? && b.nil?
+        copy(r)
+      else
+        @r = r.to_f
+        @g = g.to_f
+        @b = b.to_f
+      end
+      self
+    end
+
+    def set_scalar(scalar)
+      @r = @g = @b = scalar.to_f
+      self
+    end
+
+    def set_hex(hex)
+      hex = hex.floor
+      @r = ((hex >> 16) & 255) / 255.0
+      @g = ((hex >> 8) & 255) / 255.0
+      @b = (hex & 255) / 255.0
+      self
+    end
+
+    def set_rgb(r, g, b)
+      @r = r.to_f
+      @g = g.to_f
+      @b = b.to_f
+      self
+    end
+
+    def set_hsl(h, s, l)
+      h = h % 1
+      h += 1 if h < 0
+
+      if s.zero?
+        @r = @g = @b = l
+      else
+        p = l <= 0.5 ? l * (1 + s) : l + s - l * s
+        q = 2 * l - p
+        @r = hue_to_rgb(q, p, h + 1.0 / 3)
+        @g = hue_to_rgb(q, p, h)
+        @b = hue_to_rgb(q, p, h - 1.0 / 3)
+      end
+      self
+    end
+
+    def set_style(style)
+      if style.start_with?("#")
+        hex = style[1..].to_i(16)
+        set_hex(hex)
+      elsif style.start_with?("rgb(")
+        match = style.match(/rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/)
+        if match
+          @r = match[1].to_i / 255.0
+          @g = match[2].to_i / 255.0
+          @b = match[3].to_i / 255.0
+        end
+      end
+      self
+    end
+
+    def copy(c)
+      @r = c.r
+      @g = c.g
+      @b = c.b
+      self
+    end
+
+    def clone
+      Color.new(@r, @g, @b)
+    end
+
+    def get_hex
+      ((@r * 255).round << 16) ^ ((@g * 255).round << 8) ^ (@b * 255).round
+    end
+
+    def get_hex_string
+      format("%06x", get_hex)
+    end
+
+    def get_hsl
+      max = [@r, @g, @b].max
+      min = [@r, @g, @b].min
+
+      l = (min + max) / 2.0
+
+      if min == max
+        h = 0
+        s = 0
+      else
+        delta = max - min
+        s = l <= 0.5 ? delta / (max + min) : delta / (2 - max - min)
+
+        h = case max
+            when @r then ((@g - @b) / delta) + (@g < @b ? 6 : 0)
+            when @g then ((@b - @r) / delta) + 2
+            when @b then ((@r - @g) / delta) + 4
+            end
+        h /= 6
+      end
+
+      { h: h, s: s, l: l }
+    end
+
+    def get_style
+      "rgb(#{(@r * 255).round},#{(@g * 255).round},#{(@b * 255).round})"
+    end
+
+    def +(other)
+      Color.new(@r + other.r, @g + other.g, @b + other.b)
+    end
+
+    def add!(other)
+      @r += other.r
+      @g += other.g
+      @b += other.b
+      self
+    end
+
+    def add_scalar!(s)
+      @r += s
+      @g += s
+      @b += s
+      self
+    end
+
+    def *(other)
+      if other.is_a?(Color)
+        Color.new(@r * other.r, @g * other.g, @b * other.b)
+      else
+        Color.new(@r * other, @g * other, @b * other)
+      end
+    end
+
+    def multiply!(other)
+      @r *= other.r
+      @g *= other.g
+      @b *= other.b
+      self
+    end
+
+    def multiply_scalar!(s)
+      @r *= s
+      @g *= s
+      @b *= s
+      self
+    end
+
+    def lerp(other, alpha)
+      Color.new(
+        @r + (other.r - @r) * alpha,
+        @g + (other.g - @g) * alpha,
+        @b + (other.b - @b) * alpha
+      )
+    end
+
+    def lerp!(other, alpha)
+      @r += (other.r - @r) * alpha
+      @g += (other.g - @g) * alpha
+      @b += (other.b - @b) * alpha
+      self
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Color)
+
+      (@r - other.r).abs < Float::EPSILON &&
+        (@g - other.g).abs < Float::EPSILON &&
+        (@b - other.b).abs < Float::EPSILON
+    end
+
+    def to_a
+      [@r, @g, @b]
+    end
+
+    def to_h
+      { r: @r, g: @g, b: @b }
+    end
+
+    def inspect
+      "#<Sunrb::Color r=#{@r} g=#{@g} b=#{@b}>"
+    end
+
+    class << self
+      def white
+        new(1, 1, 1)
+      end
+
+      def black
+        new(0, 0, 0)
+      end
+
+      def red
+        new(1, 0, 0)
+      end
+
+      def green
+        new(0, 1, 0)
+      end
+
+      def blue
+        new(0, 0, 1)
+      end
+    end
+
+    private
+
+    def hue_to_rgb(p, q, t)
+      t += 1 if t < 0
+      t -= 1 if t > 1
+
+      return p + (q - p) * 6 * t if t < 1.0 / 6
+      return q if t < 1.0 / 2
+      return p + (q - p) * 6 * (2.0 / 3 - t) if t < 2.0 / 3
+
+      p
+    end
+  end
+end

data/lib/3rb/math/euler.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class Euler
+    ROTATION_ORDERS = %w[XYZ YXZ ZXY ZYX YZX XZY].freeze
+    DEFAULT_ORDER = "XYZ"
+
+    attr_accessor :x, :y, :z, :order
+
+    def initialize(x = 0, y = 0, z = 0, order = DEFAULT_ORDER)
+      @x = x.to_f
+      @y = y.to_f
+      @z = z.to_f
+      @order = order
+    end
+
+    def set(x, y, z, order = @order)
+      @x = x.to_f
+      @y = y.to_f
+      @z = z.to_f
+      @order = order
+      self
+    end
+
+    def copy(e)
+      @x = e.x
+      @y = e.y
+      @z = e.z
+      @order = e.order
+      self
+    end
+
+    def clone
+      Euler.new(@x, @y, @z, @order)
+    end
+
+    def set_from_rotation_matrix(m, order = @order)
+      e = m.elements
+
+      m11 = e[0]
+      m12 = e[4]
+      m13 = e[8]
+      m21 = e[1]
+      m22 = e[5]
+      m23 = e[9]
+      m31 = e[2]
+      m32 = e[6]
+      m33 = e[10]
+
+      case order
+      when "XYZ"
+        @y = Math.asin(clamp(m13, -1, 1))
+        if m13.abs < 0.9999999
+          @x = Math.atan2(-m23, m33)
+          @z = Math.atan2(-m12, m11)
+        else
+          @x = Math.atan2(m32, m22)
+          @z = 0
+        end
+      when "YXZ"
+        @x = Math.asin(-clamp(m23, -1, 1))
+        if m23.abs < 0.9999999
+          @y = Math.atan2(m13, m33)
+          @z = Math.atan2(m21, m22)
+        else
+          @y = Math.atan2(-m31, m11)
+          @z = 0
+        end
+      when "ZXY"
+        @x = Math.asin(clamp(m32, -1, 1))
+        if m32.abs < 0.9999999
+          @y = Math.atan2(-m31, m33)
+          @z = Math.atan2(-m12, m22)
+        else
+          @y = 0
+          @z = Math.atan2(m21, m11)
+        end
+      when "ZYX"
+        @y = Math.asin(-clamp(m31, -1, 1))
+        if m31.abs < 0.9999999
+          @x = Math.atan2(m32, m33)
+          @z = Math.atan2(m21, m11)
+        else
+          @x = 0
+          @z = Math.atan2(-m12, m22)
+        end
+      when "YZX"
+        @z = Math.asin(clamp(m21, -1, 1))
+        if m21.abs < 0.9999999
+          @x = Math.atan2(-m23, m22)
+          @y = Math.atan2(-m31, m11)
+        else
+          @x = 0
+          @y = Math.atan2(m13, m33)
+        end
+      when "XZY"
+        @z = Math.asin(-clamp(m12, -1, 1))
+        if m12.abs < 0.9999999
+          @x = Math.atan2(m32, m22)
+          @y = Math.atan2(m13, m11)
+        else
+          @x = Math.atan2(-m23, m33)
+          @y = 0
+        end
+      end
+
+      @order = order
+      self
+    end
+
+    def set_from_quaternion(q, order = @order)
+      matrix = Matrix4.new.make_rotation_from_quaternion(q)
+      set_from_rotation_matrix(matrix, order)
+    end
+
+    def set_from_vector3(v, order = @order)
+      set(v.x, v.y, v.z, order)
+    end
+
+    def reorder(new_order)
+      q = Quaternion.new.set_from_euler(self)
+      set_from_quaternion(q, new_order)
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Euler)
+
+      (@x - other.x).abs < Float::EPSILON &&
+        (@y - other.y).abs < Float::EPSILON &&
+        (@z - other.z).abs < Float::EPSILON &&
+        @order == other.order
+    end
+
+    def to_a
+      [@x, @y, @z]
+    end
+
+    def to_h
+      { x: @x, y: @y, z: @z, order: @order }
+    end
+
+    def to_vector3
+      Vector3.new(@x, @y, @z)
+    end
+
+    def inspect
+      "#<Sunrb::Euler x=#{@x} y=#{@y} z=#{@z} order=#{@order}>"
+    end
+
+    private
+
+    def clamp(value, min, max)
+      [[value, min].max, max].min
+    end
+  end
+end

data/lib/3rb/math/math_utils.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Sunrb
+  module MathUtils
+    DEG2RAD = Math::PI / 180
+    RAD2DEG = 180 / Math::PI
+
+    module_function
+
+    def generate_uuid
+      SecureRandom.uuid
+    end
+
+    def clamp(value, min, max)
+      [[value, min].max, max].min
+    end
+
+    def euclidean_modulo(n, m)
+      ((n % m) + m) % m
+    end
+
+    def map_linear(x, a1, a2, b1, b2)
+      b1 + (x - a1) * (b2 - b1) / (a2 - a1)
+    end
+
+    def lerp(x, y, t)
+      (1 - t) * x + t * y
+    end
+
+    def inverse_lerp(x, y, value)
+      return 0.0 if x == y
+
+      (value - x).to_f / (y - x)
+    end
+
+    def damp(x, y, lambda_val, dt)
+      lerp(x, y, 1 - Math.exp(-lambda_val * dt))
+    end
+
+    def ping_pong(x, length = 1)
+      length - (euclidean_modulo(x, length * 2) - length).abs
+    end
+
+    def smooth_step(x, min, max)
+      return 0 if x <= min
+      return 1 if x >= max
+
+      x = (x - min) / (max - min)
+      x * x * (3 - 2 * x)
+    end
+
+    def smoother_step(x, min, max)
+      return 0 if x <= min
+      return 1 if x >= max
+
+      x = (x - min) / (max - min)
+      x * x * x * (x * (x * 6 - 15) + 10)
+    end
+
+    def random_int(low, high)
+      low + (rand * (high - low + 1)).floor
+    end
+
+    def random_float(low, high)
+      low + rand * (high - low)
+    end
+
+    def random_float_spread(range)
+      range * (0.5 - rand)
+    end
+
+    def seeded_random(seed)
+      # Simple seeded random using modular arithmetic
+      x = Math.sin(seed) * 10000
+      x - x.floor
+    end
+
+    def deg_to_rad(degrees)
+      degrees * DEG2RAD
+    end
+
+    def rad_to_deg(radians)
+      radians * RAD2DEG
+    end
+
+    def is_power_of_two(value)
+      (value & (value - 1)).zero? && value != 0
+    end
+
+    def ceil_power_of_two(value)
+      2 ** Math.log2(value).ceil
+    end
+
+    def floor_power_of_two(value)
+      2 ** Math.log2(value).floor
+    end
+
+    def nearest_power_of_two(value)
+      2 ** Math.log2(value).round
+    end
+
+    def denormalize(value, array)
+      case array
+      when Array
+        case array.first
+        when Integer
+          value * 255
+        else
+          value
+        end
+      else
+        value
+      end
+    end
+
+    def normalize(value, array)
+      case array
+      when Array
+        case array.first
+        when Integer
+          value / 255.0
+        else
+          value
+        end
+      else
+        value
+      end
+    end
+  end
+end