three-rb 0.1.0

data/lib/three/core/buffer_geometry.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require_relative "../dirty"
+require_relative "../math/math_utils"
+require_relative "../math/vector3"
+require_relative "buffer_attribute"
+require_relative "event_dispatcher"
+
+module Three
+  class BufferGeometry < EventDispatcher
+    include Dirty
+
+    @next_id = 0
+
+    class << self
+      attr_accessor :next_id
+    end
+
+    attr_reader :id, :uuid
+    attr_accessor :name, :type, :index, :attributes, :groups, :draw_range
+    attr_accessor :bounding_box, :bounding_sphere, :user_data
+
+    def initialize
+      super()
+      @id = self.class.allocate_id
+      @uuid = MathUtils.generate_uuid
+      @name = ""
+      @type = "BufferGeometry"
+      @index = nil
+      @attributes = {}
+      @groups = []
+      @bounding_box = nil
+      @bounding_sphere = nil
+      @draw_range = { start: 0, count: Float::INFINITY }
+      @user_data = {}
+      mark_dirty!
+    end
+
+    def self.allocate_id
+      id = BufferGeometry.next_id
+      BufferGeometry.next_id += 1
+      id
+    end
+
+    def get_index
+      @index
+    end
+
+    def set_index(index)
+      @index =
+        if index.is_a?(Array)
+          attribute_class = index.any? { |value| value > 65_535 } ? Uint32BufferAttribute : Uint16BufferAttribute
+          attribute_class.new(index, 1)
+        else
+          index
+        end
+      bind_attribute_change(@index)
+      mark_dirty!(:index)
+      self
+    end
+
+    def get_attribute(name)
+      @attributes[name.to_sym]
+    end
+
+    def set_attribute(name, attribute)
+      @attributes[name.to_sym] = attribute
+      bind_attribute_change(attribute)
+      mark_dirty!(:attributes)
+      self
+    end
+
+    def delete_attribute(name)
+      @attributes.delete(name.to_sym)
+      mark_dirty!(:attributes)
+      self
+    end
+
+    def has_attribute?(name)
+      @attributes.key?(name.to_sym)
+    end
+
+    def add_group(start, count, material_index = 0)
+      @groups << { start: start, count: count, material_index: material_index }
+      mark_dirty!(:groups)
+      self
+    end
+
+    def clear_groups
+      @groups.clear
+      mark_dirty!(:groups)
+      self
+    end
+
+    def set_draw_range(start, count)
+      @draw_range[:start] = start
+      @draw_range[:count] = count
+      mark_dirty!(:draw_range)
+      self
+    end
+
+    def compute_bounding_box
+      position = get_attribute(:position)
+      @bounding_box = nil
+      return self unless position && position.count.positive?
+
+      min = Vector3.new(Float::INFINITY, Float::INFINITY, Float::INFINITY)
+      max = Vector3.new(-Float::INFINITY, -Float::INFINITY, -Float::INFINITY)
+
+      position.count.times do |index|
+        x = position.get_x(index)
+        y = position.get_y(index)
+        z = position.get_z(index)
+        min.x = [min.x, x].min
+        min.y = [min.y, y].min
+        min.z = [min.z, z].min
+        max.x = [max.x, x].max
+        max.y = [max.y, y].max
+        max.z = [max.z, z].max
+      end
+
+      @bounding_box = { min: min, max: max }
+      self
+    end
+
+    def compute_bounding_sphere
+      compute_bounding_box unless @bounding_box
+      position = get_attribute(:position)
+      @bounding_sphere = nil
+      return self unless position && @bounding_box
+
+      center = @bounding_box[:min].clone.add(@bounding_box[:max]).multiply_scalar(0.5)
+      max_radius_sq = 0
+
+      position.count.times do |index|
+        point = Vector3.new(position.get_x(index), position.get_y(index), position.get_z(index))
+        max_radius_sq = [max_radius_sq, center.distance_to_squared(point)].max
+      end
+
+      @bounding_sphere = { center: center, radius: Math.sqrt(max_radius_sq) }
+      self
+    end
+
+    def dispose
+      dispatch_event(:dispose)
+    end
+
+    def to_h
+      {
+        uuid: @uuid,
+        type: @type,
+        name: @name,
+        index: @index&.to_h,
+        attributes: @attributes.transform_values(&:to_h),
+        groups: @groups.map(&:dup),
+        bounding_box: serialize_bounds(@bounding_box),
+        bounding_sphere: serialize_sphere(@bounding_sphere)
+      }
+    end
+
+    private
+
+    def serialize_bounds(bounds)
+      return nil unless bounds
+
+      { min: bounds[:min].to_a, max: bounds[:max].to_a }
+    end
+
+    def serialize_sphere(sphere)
+      return nil unless sphere
+
+      { center: sphere[:center].to_a, radius: sphere[:radius] }
+    end
+
+    def bind_attribute_change(attribute)
+      return unless attribute.respond_to?(:on)
+
+      attribute.on(:change) { mark_dirty!(:attributes) }
+    end
+  end
+end

data/lib/three/core/clock.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Three
+  class Clock
+    attr_accessor :auto_start
+    attr_reader :start_time, :old_time, :elapsed_time, :running
+
+    def initialize(auto_start: true, time_source: nil)
+      @auto_start = auto_start
+      @time_source = time_source || proc { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+      @start_time = 0
+      @old_time = 0
+      @elapsed_time = 0
+      @running = false
+    end
+
+    def start
+      @start_time = now
+      @old_time = @start_time
+      @elapsed_time = 0
+      @running = true
+      self
+    end
+
+    def stop
+      get_elapsed_time
+      @running = false
+      @auto_start = false
+      self
+    end
+
+    def get_elapsed_time
+      get_delta
+      @elapsed_time
+    end
+
+    def get_delta
+      if @auto_start && !@running
+        start
+        return 0
+      end
+
+      return 0 unless @running
+
+      current_time = now
+      diff = current_time - @old_time
+      @old_time = current_time
+      @elapsed_time += diff
+      diff
+    end
+
+    private
+
+    def now
+      @time_source.call.to_f
+    end
+  end
+end

data/lib/three/core/event_dispatcher.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Three
+  class EventDispatcher
+    Event = Struct.new(:type, :target, :data, keyword_init: true)
+
+    def initialize
+      @listeners = Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    def add_event_listener(type, listener = nil, &block)
+      callback = listener || block
+      raise ArgumentError, "listener or block is required" unless callback
+
+      listeners = @listeners[type.to_sym]
+      listeners << callback unless listeners.include?(callback)
+      self
+    end
+
+    alias on add_event_listener
+
+    def has_event_listener?(type, listener)
+      @listeners[type.to_sym].include?(listener)
+    end
+
+    def remove_event_listener(type, listener)
+      @listeners[type.to_sym].delete(listener)
+      self
+    end
+
+    alias off remove_event_listener
+
+    def dispatch_event(event, data = nil)
+      event = normalize_event(event, data)
+      listeners = @listeners[event.type.to_sym]
+      return self if listeners.empty?
+
+      event.target = self
+      listeners.dup.each { |listener| listener.call(event) }
+      event.target = nil
+      self
+    end
+
+    private
+
+    def normalize_event(event, data)
+      case event
+      when Event
+        event
+      when Hash
+        Event.new(type: event.fetch(:type), data: event)
+      else
+        Event.new(type: event, data: data)
+      end
+    end
+  end
+end

data/lib/three/core/layers.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Three
+  class Layers
+    ALL_MASK = 0xffffffff
+
+    attr_reader :mask
+
+    def initialize
+      @mask = 1
+      @on_change_callback = proc {}
+    end
+
+    def mask=(value)
+      @mask = value.to_i
+      changed!
+    end
+
+    def set(channel)
+      self.mask = bit(channel)
+      self
+    end
+
+    def enable(channel)
+      self.mask = @mask | bit(channel)
+      self
+    end
+
+    def enable_all
+      self.mask = ALL_MASK
+      self
+    end
+
+    def toggle(channel)
+      self.mask = @mask ^ bit(channel)
+      self
+    end
+
+    def disable(channel)
+      self.mask = @mask & ~bit(channel)
+      self
+    end
+
+    def disable_all
+      self.mask = 0
+      self
+    end
+
+    def test(layers)
+      (@mask & layers.mask) != 0
+    end
+
+    def is_enabled(channel)
+      (@mask & bit(channel)) != 0
+    end
+
+    def on_change(&callback)
+      @on_change_callback = callback || proc {}
+      self
+    end
+
+    private
+
+    def bit(channel)
+      channel = Integer(channel)
+      raise RangeError, "layer channel must be between 0 and 31" unless channel.between?(0, 31)
+
+      1 << channel
+    end
+
+    def changed!
+      @on_change_callback.call
+    end
+  end
+end

data/lib/three/core/object3d.rb

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+require_relative "../math/euler"
+require_relative "../math/math_utils"
+require_relative "../math/matrix4"
+require_relative "../math/quaternion"
+require_relative "../math/vector3"
+require_relative "../dirty"
+require_relative "event_dispatcher"
+require_relative "layers"
+
+module Three
+  class Object3D < EventDispatcher
+    include Dirty
+
+    DEFAULT_UP = Vector3.new(0, 1, 0)
+    DEFAULT_MATRIX_AUTO_UPDATE = true
+    DEFAULT_MATRIX_WORLD_AUTO_UPDATE = true
+
+    @next_id = 0
+
+    class << self
+      attr_accessor :next_id
+    end
+
+    attr_reader :id, :uuid, :parent, :children
+    attr_reader :layers
+    attr_reader :position, :rotation, :quaternion, :scale
+    attr_reader :matrix, :matrix_world
+    attr_reader :name, :type, :up, :visible, :cast_shadow, :receive_shadow
+    attr_accessor :matrix_auto_update, :matrix_world_auto_update, :matrix_world_needs_update
+    attr_accessor :user_data
+
+    def initialize
+      super
+
+      @id = self.class.allocate_id
+      @uuid = MathUtils.generate_uuid
+      @name = ""
+      @type = "Object3D"
+      @parent = nil
+      @children = []
+      @layers = Layers.new
+      @up = DEFAULT_UP.clone
+
+      @position = Vector3.new
+      @rotation = Euler.new
+      @quaternion = Quaternion.new
+      @scale = Vector3.new(1, 1, 1)
+      @matrix = Matrix4.new
+      @matrix_world = Matrix4.new
+      @matrix_auto_update = DEFAULT_MATRIX_AUTO_UPDATE
+      @matrix_world_auto_update = DEFAULT_MATRIX_WORLD_AUTO_UPDATE
+      @matrix_world_needs_update = false
+      @visible = true
+      @cast_shadow = false
+      @receive_shadow = false
+      @user_data = {}
+
+      bind_rotation_and_quaternion
+      bind_transform_changes
+      bind_layer_changes
+      mark_dirty!
+    end
+
+    def name=(value)
+      @name = value
+      mark_dirty!(:properties)
+    end
+
+    def type=(value)
+      @type = value
+      mark_dirty!(:properties)
+    end
+
+    def up=(value)
+      @up = value
+      mark_dirty!(:transform)
+    end
+
+    def visible=(value)
+      @visible = value
+      mark_dirty!(:properties)
+    end
+
+    def cast_shadow=(value)
+      @cast_shadow = value
+      mark_dirty!(:properties)
+    end
+
+    def receive_shadow=(value)
+      @receive_shadow = value
+      mark_dirty!(:properties)
+    end
+
+    def mark_dirty!(field = :all)
+      super
+      @parent&.mark_descendant_dirty!
+      self
+    end
+
+    def mark_descendant_dirty!
+      return self if dirty_fields.key?(:descendants)
+
+      dirty_fields[:descendants] = true
+      @parent&.mark_descendant_dirty!
+      self
+    end
+
+    def dirty_dependency_changed(_resource, _field)
+      mark_dirty!(:resources)
+    end
+
+    def self.allocate_id
+      id = Object3D.next_id
+      Object3D.next_id += 1
+      id
+    end
+
+    def add(*objects)
+      objects.each { |object| add_one(object) }
+      self
+    end
+
+    def remove(*objects)
+      objects.each { |object| remove_one(object) }
+      self
+    end
+
+    def remove_from_parent
+      @parent&.remove(self)
+      self
+    end
+
+    def clear
+      remove(*@children.dup)
+    end
+
+    def traverse(&block)
+      return enum_for(:traverse) unless block
+
+      block.call(self)
+      @children.each { |child| child.traverse(&block) }
+      self
+    end
+
+    def traverse_visible(&block)
+      return enum_for(:traverse_visible) unless block
+      return self unless @visible
+
+      block.call(self)
+      @children.each { |child| child.traverse_visible(&block) }
+      self
+    end
+
+    def traverse_ancestors(&block)
+      return enum_for(:traverse_ancestors) unless block
+      return self unless @parent
+
+      block.call(@parent)
+      @parent.traverse_ancestors(&block)
+      self
+    end
+
+    def get_object_by_id(id)
+      get_object_by_property(:id, id)
+    end
+
+    def get_object_by_name(name)
+      get_object_by_property(:name, name)
+    end
+
+    def get_object_by_property(property, value)
+      return self if public_send(property) == value
+
+      @children.each do |child|
+        object = child.get_object_by_property(property, value)
+        return object if object
+      end
+
+      nil
+    end
+
+    def get_objects_by_property(property, value, result = [])
+      result << self if public_send(property) == value
+      @children.each { |child| child.get_objects_by_property(property, value, result) }
+      result
+    end
+
+    def update_matrix
+      @matrix.compose(@position, @quaternion, @scale)
+      @matrix_world_needs_update = true
+      self
+    end
+
+    def update_matrix_world(force = false)
+      update_matrix if @matrix_auto_update
+
+      if @matrix_world_needs_update || force
+        if @matrix_world_auto_update
+          if @parent
+            @matrix_world.multiply_matrices(@parent.matrix_world, @matrix)
+          else
+            @matrix_world.copy(@matrix)
+          end
+        end
+
+        @matrix_world_needs_update = false
+        force = true
+      end
+
+      @children.each { |child| child.update_matrix_world(force) }
+      self
+    end
+
+    def update_world_matrix(update_parents = false, update_children = false)
+      @parent&.update_world_matrix(true, false) if update_parents
+      update_matrix if @matrix_auto_update
+
+      if @matrix_world_auto_update
+        if @parent
+          @matrix_world.multiply_matrices(@parent.matrix_world, @matrix)
+        else
+          @matrix_world.copy(@matrix)
+        end
+      end
+
+      @children.each { |child| child.update_world_matrix(false, true) } if update_children
+      self
+    end
+
+    def get_world_position(target = Vector3.new)
+      update_world_matrix(true, false)
+      target.set_from_matrix_position(@matrix_world)
+    end
+
+    def get_world_quaternion(target = Quaternion.new)
+      update_world_matrix(true, false)
+      @matrix_world.decompose(Vector3.new, target, Vector3.new)
+      target
+    end
+
+    def get_world_scale(target = Vector3.new)
+      update_world_matrix(true, false)
+      @matrix_world.decompose(Vector3.new, Quaternion.new, target)
+      target
+    end
+
+    def get_world_direction(target = Vector3.new)
+      update_world_matrix(true, false)
+      elements = @matrix_world.elements
+      target.set(elements[8], elements[9], elements[10]).normalize
+    end
+
+    def to_h
+      {
+        uuid: @uuid,
+        type: @type,
+        name: @name,
+        matrix: @matrix.to_a,
+        layers: @layers.mask,
+        visible: @visible,
+        cast_shadow: @cast_shadow,
+        receive_shadow: @receive_shadow,
+        user_data: @user_data,
+        children: @children.map(&:to_h)
+      }
+    end
+
+    def to_json(*args)
+      Exporters::ThreeJSONExporter.new.to_json(self, *args)
+    end
+
+    protected
+
+    attr_writer :parent
+
+    private
+
+    def add_one(object)
+      raise ArgumentError, "object cannot be added as a child of itself" if object.equal?(self)
+      raise TypeError, "object must be a Three::Object3D" unless object.is_a?(Object3D)
+
+      object.remove_from_parent
+      object.parent = self
+      @children << object
+      mark_dirty!(:children)
+      object.mark_dirty!(:transform)
+      object.dispatch_event(:added)
+      dispatch_event(:childadded, object)
+    end
+
+    def remove_one(object)
+      return unless @children.include?(object)
+
+      @children.delete(object)
+      object.parent = nil
+      mark_dirty!(:children)
+      object.mark_dirty!(:transform)
+      object.dispatch_event(:removed)
+      dispatch_event(:childremoved, object)
+    end
+
+    def bind_rotation_and_quaternion
+      @rotation.on_change do
+        @quaternion.set_from_euler(@rotation, update: false)
+        @matrix_world_needs_update = true
+        mark_dirty!(:transform)
+      end
+
+      @quaternion.on_change do
+        @rotation.set_from_quaternion(@quaternion, @rotation.order, update: false)
+        @matrix_world_needs_update = true
+        mark_dirty!(:transform)
+      end
+    end
+
+    def bind_transform_changes
+      [@position, @scale].each do |vector|
+        vector.on_change do
+          @matrix_world_needs_update = true
+          mark_dirty!(:transform)
+        end
+      end
+    end
+
+    def bind_layer_changes
+      @layers.on_change { mark_dirty!(:properties) }
+    end
+  end
+end