3rb 0.1.0

data/lib/3rb/controls/orbit_controls.rb

@@ -0,0 +1,341 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class OrbitControls
+    STATE = {
+      none: -1,
+      rotate: 0,
+      dolly: 1,
+      pan: 2,
+      touch_rotate: 3,
+      touch_pan: 4,
+      touch_dolly_pan: 5,
+      touch_dolly_rotate: 6
+    }.freeze
+
+    attr_accessor :object, :dom_element
+    attr_accessor :enabled, :target
+    attr_accessor :min_distance, :max_distance
+    attr_accessor :min_zoom, :max_zoom
+    attr_accessor :min_polar_angle, :max_polar_angle
+    attr_accessor :min_azimuth_angle, :max_azimuth_angle
+    attr_accessor :enable_damping, :damping_factor
+    attr_accessor :enable_zoom, :zoom_speed
+    attr_accessor :enable_rotate, :rotate_speed
+    attr_accessor :enable_pan, :pan_speed, :screen_space_panning
+    attr_accessor :key_pan_speed
+    attr_accessor :auto_rotate, :auto_rotate_speed
+
+    def initialize(object, dom_element = nil)
+      @object = object
+      @dom_element = dom_element
+
+      @enabled = true
+      @target = Vector3.new
+
+      @min_distance = 0
+      @max_distance = Float::INFINITY
+
+      @min_zoom = 0
+      @max_zoom = Float::INFINITY
+
+      @min_polar_angle = 0
+      @max_polar_angle = Math::PI
+
+      @min_azimuth_angle = -Float::INFINITY
+      @max_azimuth_angle = Float::INFINITY
+
+      @enable_damping = false
+      @damping_factor = 0.05
+
+      @enable_zoom = true
+      @zoom_speed = 1.0
+
+      @enable_rotate = true
+      @rotate_speed = 1.0
+
+      @enable_pan = true
+      @pan_speed = 1.0
+      @screen_space_panning = true
+      @key_pan_speed = 7.0
+
+      @auto_rotate = false
+      @auto_rotate_speed = 2.0
+
+      @state = STATE[:none]
+
+      @spherical = Spherical.new
+      @spherical_delta = Spherical.new
+
+      @scale = 1
+      @pan_offset = Vector3.new
+      @zoom_changed = false
+
+      @rotate_start = Vector2.new
+      @rotate_end = Vector2.new
+      @rotate_delta = Vector2.new
+
+      @pan_start = Vector2.new
+      @pan_end = Vector2.new
+      @pan_delta = Vector2.new
+
+      @dolly_start = Vector2.new
+      @dolly_end = Vector2.new
+      @dolly_delta = Vector2.new
+
+      @offset = Vector3.new
+      @quat = Quaternion.new
+      @quat_inverse = Quaternion.new
+      @last_position = Vector3.new
+      @last_quaternion = Quaternion.new
+
+      update
+    end
+
+    def update(delta_time = nil)
+      position = @object.position
+
+      @offset.copy(position).sub(@target)
+
+      @quat.set_from_euler(Euler.new(0, 0, 0))
+      @quat_inverse.copy(@quat).invert
+
+      @offset.apply_quaternion(@quat)
+
+      @spherical.set_from_vector3(@offset)
+
+      if @auto_rotate && @state == STATE[:none]
+        rotate_left(auto_rotation_angle(delta_time))
+      end
+
+      if @enable_damping
+        @spherical.theta += @spherical_delta.theta * @damping_factor
+        @spherical.phi += @spherical_delta.phi * @damping_factor
+      else
+        @spherical.theta += @spherical_delta.theta
+        @spherical.phi += @spherical_delta.phi
+      end
+
+      @spherical.theta = clamp_azimuth_angle(@spherical.theta)
+      @spherical.phi = [@min_polar_angle, [@max_polar_angle, @spherical.phi].min].max
+
+      @spherical.make_safe
+
+      @spherical.radius *= @scale
+
+      @spherical.radius = [@min_distance, [@max_distance, @spherical.radius].min].max
+
+      if @enable_damping
+        @target.add(@pan_offset.multiply_scalar(@damping_factor))
+      else
+        @target.add(@pan_offset)
+      end
+
+      @offset.set_from_spherical(@spherical)
+      @offset.apply_quaternion(@quat_inverse)
+
+      position.copy(@target).add(@offset)
+
+      @object.look_at(@target)
+
+      if @enable_damping
+        @spherical_delta.theta *= (1 - @damping_factor)
+        @spherical_delta.phi *= (1 - @damping_factor)
+        @pan_offset.multiply_scalar(1 - @damping_factor)
+      else
+        @spherical_delta.set(0, 0, 0)
+        @pan_offset.set(0, 0, 0)
+      end
+
+      @scale = 1
+
+      if @zoom_changed ||
+         @last_position.distance_to(@object.position) > 0.000001 ||
+         8 * (1 - @last_quaternion.dot(@object.quaternion)) > 0.000001
+
+        @last_position.copy(@object.position)
+        @last_quaternion.copy(@object.quaternion)
+        @zoom_changed = false
+
+        true
+      else
+        false
+      end
+    end
+
+    def rotate_left(angle)
+      @spherical_delta.theta -= angle
+    end
+
+    def rotate_up(angle)
+      @spherical_delta.phi -= angle
+    end
+
+    def pan_left(distance, object_matrix)
+      v = Vector3.new
+      v.set_from_matrix_column(object_matrix, 0)
+      v.multiply_scalar(-distance)
+      @pan_offset.add(v)
+    end
+
+    def pan_up(distance, object_matrix)
+      v = Vector3.new
+
+      if @screen_space_panning
+        v.set_from_matrix_column(object_matrix, 1)
+      else
+        v.set_from_matrix_column(object_matrix, 0)
+        v.cross_vectors(@object.up, v)
+      end
+
+      v.multiply_scalar(distance)
+      @pan_offset.add(v)
+    end
+
+    def pan(delta_x, delta_y)
+      element = @dom_element
+
+      if @object.is_a?(PerspectiveCamera)
+        position = @object.position
+        offset = position.clone.sub(@target)
+        target_distance = offset.length
+
+        target_distance *= Math.tan((@object.fov / 2) * Math::PI / 180.0)
+
+        height = element ? element[:height] : 1
+        pan_left(2 * delta_x * target_distance / height, @object.matrix_world)
+        pan_up(2 * delta_y * target_distance / height, @object.matrix_world)
+      elsif @object.is_a?(OrthographicCamera)
+        width = element ? element[:width] : 1
+        height = element ? element[:height] : 1
+        pan_left(delta_x * (@object.right - @object.left) / @object.zoom / width, @object.matrix_world)
+        pan_up(delta_y * (@object.top - @object.bottom) / @object.zoom / height, @object.matrix_world)
+      end
+    end
+
+    def dolly_out(dolly_scale)
+      if @object.is_a?(PerspectiveCamera)
+        @scale /= dolly_scale
+      elsif @object.is_a?(OrthographicCamera)
+        @object.zoom = [@min_zoom, [@max_zoom, @object.zoom / dolly_scale].min].max
+        @object.update_projection_matrix
+        @zoom_changed = true
+      end
+    end
+
+    def dolly_in(dolly_scale)
+      if @object.is_a?(PerspectiveCamera)
+        @scale *= dolly_scale
+      elsif @object.is_a?(OrthographicCamera)
+        @object.zoom = [@min_zoom, [@max_zoom, @object.zoom * dolly_scale].min].max
+        @object.update_projection_matrix
+        @zoom_changed = true
+      end
+    end
+
+    def reset
+      @target.copy(Vector3.new)
+      @object.position.copy(Vector3.new(0, 0, 1))
+      @object.zoom = 1
+      @object.update_projection_matrix if @object.respond_to?(:update_projection_matrix)
+      update
+      @state = STATE[:none]
+    end
+
+    def save_state
+      @target0 = @target.clone
+      @position0 = @object.position.clone
+      @zoom0 = @object.zoom
+    end
+
+    def get_polar_angle
+      @spherical.phi
+    end
+
+    def get_azimuthal_angle
+      @spherical.theta
+    end
+
+    def get_distance
+      @object.position.distance_to(@target)
+    end
+
+    def dispose
+      # Clean up event listeners if any
+    end
+
+    private
+
+    def auto_rotation_angle(delta_time)
+      if delta_time
+        (2 * Math::PI / 60 / 60) * @auto_rotate_speed * delta_time
+      else
+        (2 * Math::PI / 60 / 60) * @auto_rotate_speed
+      end
+    end
+
+    def clamp_azimuth_angle(angle)
+      return angle if @min_azimuth_angle == -Float::INFINITY && @max_azimuth_angle == Float::INFINITY
+
+      if angle < -Math::PI
+        angle += 2 * Math::PI
+      elsif angle > Math::PI
+        angle -= 2 * Math::PI
+      end
+
+      [@min_azimuth_angle, [@max_azimuth_angle, angle].min].max
+    end
+  end
+
+  class Spherical
+    attr_accessor :radius, :phi, :theta
+
+    def initialize(radius = 1.0, phi = 0, theta = 0)
+      @radius = radius
+      @phi = phi
+      @theta = theta
+    end
+
+    def set(radius, phi, theta)
+      @radius = radius
+      @phi = phi
+      @theta = theta
+      self
+    end
+
+    def copy(other)
+      @radius = other.radius
+      @phi = other.phi
+      @theta = other.theta
+      self
+    end
+
+    def clone
+      Spherical.new(@radius, @phi, @theta)
+    end
+
+    def make_safe
+      eps = 0.000001
+      @phi = [eps, [Math::PI - eps, @phi].min].max
+      self
+    end
+
+    def set_from_vector3(v)
+      set_from_cartesian_coords(v.x, v.y, v.z)
+    end
+
+    def set_from_cartesian_coords(x, y, z)
+      @radius = Math.sqrt(x * x + y * y + z * z)
+
+      if @radius == 0
+        @theta = 0
+        @phi = 0
+      else
+        @theta = Math.atan2(x, z)
+        @phi = Math.acos([[-1, y / @radius].max, 1].min)
+      end
+
+      self
+    end
+  end
+end

data/lib/3rb/core/buffer_attribute.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class BufferAttribute
+    attr_accessor :array, :item_size, :normalized
+    attr_accessor :usage, :update_range
+    attr_reader :count, :version
+
+    STATIC_DRAW = 35044
+    DYNAMIC_DRAW = 35048
+
+    def initialize(array, item_size, normalized: false)
+      @array = array.is_a?(Array) ? array.map(&:to_f) : array
+      @item_size = item_size
+      @normalized = normalized
+      @count = @array.length / item_size
+      @version = 0
+      @usage = STATIC_DRAW
+      @update_range = { offset: 0, count: -1 }
+    end
+
+    def needs_update=(value)
+      @version += 1 if value
+    end
+
+    def set_usage(value)
+      @usage = value
+      self
+    end
+
+    def get_x(index)
+      @array[index * @item_size]
+    end
+
+    def set_x(index, x)
+      @array[index * @item_size] = x.to_f
+      self
+    end
+
+    def get_y(index)
+      @array[index * @item_size + 1]
+    end
+
+    def set_y(index, y)
+      @array[index * @item_size + 1] = y.to_f
+      self
+    end
+
+    def get_z(index)
+      @array[index * @item_size + 2]
+    end
+
+    def set_z(index, z)
+      @array[index * @item_size + 2] = z.to_f
+      self
+    end
+
+    def get_w(index)
+      @array[index * @item_size + 3]
+    end
+
+    def set_w(index, w)
+      @array[index * @item_size + 3] = w.to_f
+      self
+    end
+
+    def set_xy(index, x, y)
+      idx = index * @item_size
+      @array[idx] = x.to_f
+      @array[idx + 1] = y.to_f
+      self
+    end
+
+    def set_xyz(index, x, y, z)
+      idx = index * @item_size
+      @array[idx] = x.to_f
+      @array[idx + 1] = y.to_f
+      @array[idx + 2] = z.to_f
+      self
+    end
+
+    def set_xyzw(index, x, y, z, w)
+      idx = index * @item_size
+      @array[idx] = x.to_f
+      @array[idx + 1] = y.to_f
+      @array[idx + 2] = z.to_f
+      @array[idx + 3] = w.to_f
+      self
+    end
+
+    def copy_at(index1, attribute, index2)
+      idx1 = index1 * @item_size
+      idx2 = index2 * attribute.item_size
+      @item_size.times do |i|
+        @array[idx1 + i] = attribute.array[idx2 + i]
+      end
+      self
+    end
+
+    def copy_array(array)
+      @array = array.map(&:to_f)
+      self
+    end
+
+    def apply_matrix3(m)
+      return self if @item_size != 2
+
+      v = Vector2.new
+      @count.times do |i|
+        v.x = get_x(i)
+        v.y = get_y(i)
+        v.apply_matrix3(m)
+        set_xy(i, v.x, v.y)
+      end
+      self
+    end
+
+    def apply_matrix4(m)
+      return self if @item_size < 3
+
+      v = Vector3.new
+      @count.times do |i|
+        v.x = get_x(i)
+        v.y = get_y(i)
+        v.z = get_z(i)
+        v.apply_matrix4(m)
+        set_xyz(i, v.x, v.y, v.z)
+      end
+      self
+    end
+
+    def apply_normal_matrix(m)
+      return self if @item_size != 3
+
+      v = Vector3.new
+      @count.times do |i|
+        v.x = get_x(i)
+        v.y = get_y(i)
+        v.z = get_z(i)
+        v.apply_matrix3(m).normalize!
+        set_xyz(i, v.x, v.y, v.z)
+      end
+      self
+    end
+
+    def clone
+      BufferAttribute.new(@array.dup, @item_size, normalized: @normalized)
+    end
+
+    def to_a
+      @array.dup
+    end
+  end
+
+  class Float32BufferAttribute < BufferAttribute
+    def initialize(array, item_size, normalized: false)
+      super(array, item_size, normalized: normalized)
+    end
+  end
+
+  class Uint16BufferAttribute < BufferAttribute
+    def initialize(array, item_size, normalized: false)
+      super(array.map(&:to_i), item_size, normalized: normalized)
+    end
+  end
+
+  class Uint32BufferAttribute < BufferAttribute
+    def initialize(array, item_size, normalized: false)
+      super(array.map(&:to_i), item_size, normalized: normalized)
+    end
+  end
+end

data/lib/3rb/core/group.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class Group < Object3D
+    def initialize
+      super
+    end
+  end
+end