three-rb 0.1.0

data/lib/three/math/vector2.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Three
+  class Vector2
+    include Enumerable
+
+    attr_reader :x, :y
+
+    def initialize(x = 0, y = 0)
+      @x = x
+      @y = y
+      @on_change_callback = proc {}
+    end
+
+    def x=(value)
+      @x = value
+      changed!
+    end
+
+    def y=(value)
+      @y = value
+      changed!
+    end
+
+    def set(x, y)
+      @x = x
+      @y = y
+      changed!
+      self
+    end
+
+    def set_scalar(scalar)
+      set(scalar, scalar)
+    end
+
+    def clone
+      self.class.new(@x, @y)
+    end
+
+    def copy(vector)
+      set(vector.x, vector.y)
+    end
+
+    def from_array(array, offset = 0)
+      set(array[offset], array[offset + 1])
+    end
+
+    def to_array(array = [], offset = 0)
+      array[offset] = @x
+      array[offset + 1] = @y
+      array
+    end
+
+    def equals?(vector, epsilon: 0.0)
+      (@x - vector.x).abs <= epsilon &&
+        (@y - vector.y).abs <= epsilon
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && equals?(other)
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      yield @x
+      yield @y
+    end
+
+    def to_a
+      [@x, @y]
+    end
+
+    def deconstruct
+      to_a
+    end
+
+    def on_change(&callback)
+      @on_change_callback = callback || proc {}
+      self
+    end
+
+    alias _on_change on_change
+
+    def inspect
+      "#<#{self.class} x=#{@x.inspect} y=#{@y.inspect}>"
+    end
+
+    private
+
+    def changed!
+      @on_change_callback.call
+    end
+  end
+end

data/lib/three/math/vector3.rb

@@ -0,0 +1,396 @@
+# frozen_string_literal: true
+
+module Three
+  class Vector3
+    include Enumerable
+
+    attr_reader :x, :y, :z
+
+    def initialize(x = 0, y = 0, z = 0)
+      @x = x
+      @y = y
+      @z = z
+      @on_change_callback = proc {}
+    end
+
+    def x=(value)
+      @x = value
+      changed!
+    end
+
+    def y=(value)
+      @y = value
+      changed!
+    end
+
+    def z=(value)
+      @z = value
+      changed!
+    end
+
+    def set(x, y, z = @z)
+      @x = x
+      @y = y
+      @z = z
+      changed!
+      self
+    end
+
+    def set_scalar(scalar)
+      @x = scalar
+      @y = scalar
+      @z = scalar
+      changed!
+      self
+    end
+
+    def set_x(x)
+      @x = x
+      changed!
+      self
+    end
+
+    def set_y(y)
+      @y = y
+      changed!
+      self
+    end
+
+    def set_z(z)
+      @z = z
+      changed!
+      self
+    end
+
+    def set_component(index, value)
+      case index
+      when 0 then @x = value
+      when 1 then @y = value
+      when 2 then @z = value
+      else raise IndexError, "index is out of range: #{index}"
+      end
+
+      changed!
+      self
+    end
+
+    def get_component(index)
+      case index
+      when 0 then @x
+      when 1 then @y
+      when 2 then @z
+      else raise IndexError, "index is out of range: #{index}"
+      end
+    end
+
+    alias [] get_component
+    alias []= set_component
+
+    def clone
+      self.class.new(@x, @y, @z)
+    end
+
+    def copy(vector)
+      @x = vector.x
+      @y = vector.y
+      @z = vector.z
+      changed!
+      self
+    end
+
+    def add(vector)
+      @x += vector.x
+      @y += vector.y
+      @z += vector.z
+      changed!
+      self
+    end
+
+    def add_scalar(scalar)
+      @x += scalar
+      @y += scalar
+      @z += scalar
+      changed!
+      self
+    end
+
+    def add_vectors(a, b)
+      @x = a.x + b.x
+      @y = a.y + b.y
+      @z = a.z + b.z
+      changed!
+      self
+    end
+
+    def add_scaled_vector(vector, scale)
+      @x += vector.x * scale
+      @y += vector.y * scale
+      @z += vector.z * scale
+      changed!
+      self
+    end
+
+    def sub(vector)
+      @x -= vector.x
+      @y -= vector.y
+      @z -= vector.z
+      changed!
+      self
+    end
+
+    def sub_scalar(scalar)
+      @x -= scalar
+      @y -= scalar
+      @z -= scalar
+      changed!
+      self
+    end
+
+    def sub_vectors(a, b)
+      @x = a.x - b.x
+      @y = a.y - b.y
+      @z = a.z - b.z
+      changed!
+      self
+    end
+
+    def multiply(vector)
+      @x *= vector.x
+      @y *= vector.y
+      @z *= vector.z
+      changed!
+      self
+    end
+
+    def multiply_scalar(scalar)
+      @x *= scalar
+      @y *= scalar
+      @z *= scalar
+      changed!
+      self
+    end
+
+    def divide(vector)
+      @x = @x.to_f / vector.x
+      @y = @y.to_f / vector.y
+      @z = @z.to_f / vector.z
+      changed!
+      self
+    end
+
+    def divide_scalar(scalar)
+      multiply_scalar(1.0 / scalar)
+    end
+
+    def negate
+      multiply_scalar(-1)
+    end
+
+    def dot(vector)
+      @x * vector.x + @y * vector.y + @z * vector.z
+    end
+
+    def cross(vector)
+      cross_vectors(self, vector)
+    end
+
+    def cross_vectors(a, b)
+      ax = a.x
+      ay = a.y
+      az = a.z
+      bx = b.x
+      by = b.y
+      bz = b.z
+
+      @x = ay * bz - az * by
+      @y = az * bx - ax * bz
+      @z = ax * by - ay * bx
+      changed!
+      self
+    end
+
+    def length_sq
+      @x * @x + @y * @y + @z * @z
+    end
+
+    def length
+      Math.sqrt(length_sq)
+    end
+
+    def manhattan_length
+      @x.abs + @y.abs + @z.abs
+    end
+
+    def normalize
+      current_length = length
+      divide_scalar(current_length.zero? ? 1 : current_length)
+    end
+
+    def set_length(value)
+      old_length = length
+      return self if old_length.zero? || old_length == value
+
+      multiply_scalar(value / old_length)
+    end
+
+    def distance_to(vector)
+      Math.sqrt(distance_to_squared(vector))
+    end
+
+    def distance_to_squared(vector)
+      dx = @x - vector.x
+      dy = @y - vector.y
+      dz = @z - vector.z
+      dx * dx + dy * dy + dz * dz
+    end
+
+    def apply_matrix4(matrix)
+      elements = matrix.elements
+      x = @x
+      y = @y
+      z = @z
+      w = 1.0 / (elements[3] * x + elements[7] * y + elements[11] * z + elements[15])
+
+      @x = (elements[0] * x + elements[4] * y + elements[8] * z + elements[12]) * w
+      @y = (elements[1] * x + elements[5] * y + elements[9] * z + elements[13]) * w
+      @z = (elements[2] * x + elements[6] * y + elements[10] * z + elements[14]) * w
+      changed!
+      self
+    end
+
+    def apply_matrix3(matrix)
+      elements = matrix.elements
+      x = @x
+      y = @y
+      z = @z
+
+      @x = elements[0] * x + elements[3] * y + elements[6] * z
+      @y = elements[1] * x + elements[4] * y + elements[7] * z
+      @z = elements[2] * x + elements[5] * y + elements[8] * z
+      changed!
+      self
+    end
+
+    def apply_quaternion(quaternion)
+      vx = @x
+      vy = @y
+      vz = @z
+      qx = quaternion.x
+      qy = quaternion.y
+      qz = quaternion.z
+      qw = quaternion.w
+
+      tx = 2 * (qy * vz - qz * vy)
+      ty = 2 * (qz * vx - qx * vz)
+      tz = 2 * (qx * vy - qy * vx)
+
+      @x = vx + qw * tx + qy * tz - qz * ty
+      @y = vy + qw * ty + qz * tx - qx * tz
+      @z = vz + qw * tz + qx * ty - qy * tx
+      changed!
+      self
+    end
+
+    def set_from_matrix_position(matrix)
+      elements = matrix.elements
+      @x = elements[12]
+      @y = elements[13]
+      @z = elements[14]
+      changed!
+      self
+    end
+
+    def set_from_matrix_scale(matrix)
+      sx = set_from_matrix_column(matrix, 0).length
+      sy = set_from_matrix_column(matrix, 1).length
+      sz = set_from_matrix_column(matrix, 2).length
+      set(sx, sy, sz)
+    end
+
+    def set_from_matrix_column(matrix, index)
+      from_array(matrix.elements, index * 4)
+    end
+
+    def set_from_matrix3_column(matrix, index)
+      from_array(matrix.elements, index * 3)
+    end
+
+    def from_array(array, offset = 0)
+      @x = array[offset]
+      @y = array[offset + 1]
+      @z = array[offset + 2]
+      changed!
+      self
+    end
+
+    def on_change(&callback)
+      @on_change_callback = callback || proc {}
+      self
+    end
+
+    alias _on_change on_change
+
+    def to_array(array = [], offset = 0)
+      array[offset] = @x
+      array[offset + 1] = @y
+      array[offset + 2] = @z
+      array
+    end
+
+    def equals?(vector, epsilon: 0.0)
+      (@x - vector.x).abs <= epsilon &&
+        (@y - vector.y).abs <= epsilon &&
+        (@z - vector.z).abs <= epsilon
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && equals?(other)
+    end
+
+    def +(other)
+      clone.add(other)
+    end
+
+    def -(other)
+      clone.sub(other)
+    end
+
+    def *(scalar)
+      clone.multiply_scalar(scalar)
+    end
+
+    def /(scalar)
+      clone.divide_scalar(scalar)
+    end
+
+    def -@
+      clone.negate
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      yield @x
+      yield @y
+      yield @z
+    end
+
+    def to_a
+      [@x, @y, @z]
+    end
+
+    def deconstruct
+      to_a
+    end
+
+    def inspect
+      "#<#{self.class} x=#{@x.inspect} y=#{@y.inspect} z=#{@z.inspect}>"
+    end
+
+    private
+
+    def changed!
+      @on_change_callback.call
+    end
+  end
+end

data/lib/three/objects/external_object3d.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../core/object3d"
+
+module Three
+  class ExternalObject3D < Object3D
+    attr_reader :handle
+
+    def initialize(handle, type: "ExternalObject3D")
+      super()
+      @handle = handle
+      @type = type
+      mark_clean!
+    end
+
+    def add(*)
+      raise NotImplementedError, "ExternalObject3D does not support Ruby child mutation yet"
+    end
+
+    def remove(*)
+      raise NotImplementedError, "ExternalObject3D does not support Ruby child mutation yet"
+    end
+
+    def clear
+      raise NotImplementedError, "ExternalObject3D does not support Ruby child mutation yet"
+    end
+  end
+end

data/lib/three/objects/group.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "../core/object3d"
+
+module Three
+  class Group < Object3D
+    def initialize
+      super
+      @type = "Group"
+    end
+  end
+end

data/lib/three/objects/instanced_mesh.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative "../core/buffer_geometry"
+require_relative "../materials/mesh_basic_material"
+require_relative "../math/color"
+require_relative "../math/matrix4"
+require_relative "mesh"
+
+module Three
+  class InstancedMesh < Mesh
+    attr_reader :count, :capacity, :instance_matrices, :instance_colors
+
+    def initialize(geometry = BufferGeometry.new, material = MeshBasicMaterial.new, count = 1)
+      super(geometry, material)
+      @type = "InstancedMesh"
+      @capacity = coerce_count(count)
+      @count = @capacity
+      @instance_matrices = Array.new(@capacity) { Matrix4.new }
+      @instance_colors = nil
+      mark_dirty!(:instances)
+    end
+
+    def count=(value)
+      integer = coerce_count(value)
+      raise ArgumentError, "count cannot exceed capacity" if integer > @capacity
+
+      @count = integer
+      mark_dirty!(:mesh)
+    end
+
+    def set_matrix_at(index, matrix)
+      validate_instance_index(index)
+      @instance_matrices[index] = coerce_matrix(matrix)
+      mark_dirty!(:instances)
+      self
+    end
+
+    def get_matrix_at(index, target = Matrix4.new)
+      validate_instance_index(index)
+      target.copy(@instance_matrices[index])
+    end
+
+    def set_color_at(index, color)
+      validate_instance_index(index)
+      ensure_instance_colors
+      @instance_colors[index] = coerce_color(color)
+      mark_dirty!(:instance_colors)
+      self
+    end
+
+    def get_color_at(index, target = Color.new)
+      validate_instance_index(index)
+      target.copy(@instance_colors ? @instance_colors[index] : Color.new)
+    end
+
+    def instance_matrix_needs_update!
+      mark_dirty!(:instances)
+      self
+    end
+
+    def instance_color_needs_update!
+      mark_dirty!(:instance_colors)
+      self
+    end
+
+    def to_h
+      super.merge(
+        count: @count,
+        capacity: @capacity,
+        instance_matrices: @instance_matrices.map(&:to_a),
+        instance_colors: @instance_colors&.map(&:to_a)
+      )
+    end
+
+    private
+
+    def coerce_count(value)
+      integer = Integer(value)
+      raise ArgumentError, "count must be non-negative" if integer.negative?
+
+      integer
+    end
+
+    def validate_instance_index(index)
+      raise IndexError, "instance index #{index} is out of range" unless index.is_a?(Integer) && index >= 0 && index < @capacity
+    end
+
+    def ensure_instance_colors
+      @instance_colors ||= Array.new(@capacity) { Color.new }
+    end
+
+    def coerce_matrix(matrix)
+      return matrix.clone if matrix.is_a?(Matrix4)
+
+      array = matrix.to_a if matrix.respond_to?(:to_a)
+      raise TypeError, "matrix must be a Three::Matrix4 or 16-element array" unless array&.length == 16
+
+      Matrix4.new.from_array(array)
+    end
+
+    def coerce_color(color)
+      return color.clone if color.is_a?(Color)
+
+      array = color.to_a if color.respond_to?(:to_a)
+      return Color.new(*array) if array&.length == 3
+
+      Color.new(color)
+    end
+  end
+end

data/lib/three/objects/line.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../core/buffer_geometry"
+require_relative "../materials/line_basic_material"
+require_relative "group"
+
+module Three
+  class Line < Object3D
+    attr_reader :geometry, :material
+
+    def initialize(geometry = BufferGeometry.new, material = LineBasicMaterial.new)
+      super()
+      @type = "Line"
+      @geometry = nil
+      @material = nil
+      self.geometry = geometry
+      self.material = material
+    end
+
+    def geometry=(value)
+      @geometry.remove_dirty_dependent(self) if @geometry.respond_to?(:remove_dirty_dependent)
+      @geometry = value
+      @geometry.add_dirty_dependent(self) if @geometry.respond_to?(:add_dirty_dependent)
+      mark_dirty!(:line)
+    end
+
+    def material=(value)
+      @material.remove_dirty_dependent(self) if @material.respond_to?(:remove_dirty_dependent)
+      @material = value
+      @material.add_dirty_dependent(self) if @material.respond_to?(:add_dirty_dependent)
+      mark_dirty!(:line)
+    end
+
+    def to_h
+      super.merge(
+        geometry: @geometry.uuid,
+        material: @material.respond_to?(:uuid) ? @material.uuid : nil
+      )
+    end
+  end
+end

data/lib/three/objects/mesh.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../core/buffer_geometry"
+require_relative "../materials/mesh_basic_material"
+require_relative "group"
+
+module Three
+  class Mesh < Object3D
+    attr_reader :geometry, :material
+    attr_accessor :morph_target_dictionary, :morph_target_influences, :count
+
+    def initialize(geometry = BufferGeometry.new, material = MeshBasicMaterial.new)
+      super()
+      @type = "Mesh"
+      @geometry = nil
+      @material = nil
+      @morph_target_dictionary = nil
+      @morph_target_influences = nil
+      @count = 1
+      self.geometry = geometry
+      self.material = material
+    end
+
+    def geometry=(value)
+      @geometry.remove_dirty_dependent(self) if @geometry.respond_to?(:remove_dirty_dependent)
+      @geometry = value
+      @geometry.add_dirty_dependent(self) if @geometry.respond_to?(:add_dirty_dependent)
+      mark_dirty!(:mesh)
+    end
+
+    def material=(value)
+      @material.remove_dirty_dependent(self) if @material.respond_to?(:remove_dirty_dependent)
+      @material = value
+      @material.add_dirty_dependent(self) if @material.respond_to?(:add_dirty_dependent)
+      mark_dirty!(:mesh)
+    end
+
+    def to_h
+      super.merge(
+        geometry: @geometry.uuid,
+        material: @material.respond_to?(:uuid) ? @material.uuid : nil
+      )
+    end
+  end
+end