three-rb 0.1.0

data/lib/three/cameras/orthographic_camera.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "camera"
+
+module Three
+  class OrthographicCamera < Camera
+    attr_reader :left, :right, :top, :bottom, :near, :far, :zoom
+    attr_reader :view
+
+    def initialize(left = -1, right = 1, top = 1, bottom = -1, near: 0.1, far: 2000)
+      super()
+      @type = "OrthographicCamera"
+      @left = left
+      @right = right
+      @top = top
+      @bottom = bottom
+      @near = near
+      @far = far
+      @zoom = 1
+      @view = nil
+      update_projection_matrix
+    end
+
+    def left=(value)
+      @left = value
+      mark_dirty!(:camera)
+    end
+
+    def right=(value)
+      @right = value
+      mark_dirty!(:camera)
+    end
+
+    def top=(value)
+      @top = value
+      mark_dirty!(:camera)
+    end
+
+    def bottom=(value)
+      @bottom = value
+      mark_dirty!(:camera)
+    end
+
+    def near=(value)
+      @near = value
+      mark_dirty!(:camera)
+    end
+
+    def far=(value)
+      @far = value
+      mark_dirty!(:camera)
+    end
+
+    def zoom=(value)
+      @zoom = value
+      mark_dirty!(:camera)
+    end
+
+    def set_view_offset(full_width, full_height, x, y, width, height)
+      @view = {
+        enabled: true,
+        full_width: full_width,
+        full_height: full_height,
+        offset_x: x,
+        offset_y: y,
+        width: width,
+        height: height
+      }
+      mark_dirty!(:camera)
+      update_projection_matrix
+      self
+    end
+
+    def clear_view_offset
+      @view[:enabled] = false if @view
+      mark_dirty!(:camera)
+      update_projection_matrix
+      self
+    end
+
+    def update_projection_matrix
+      dx = (@right - @left).to_f / (2 * @zoom)
+      dy = (@top - @bottom).to_f / (2 * @zoom)
+      cx = (@right + @left).to_f / 2
+      cy = (@top + @bottom).to_f / 2
+
+      left = cx - dx
+      right = cx + dx
+      top = cy + dy
+      bottom = cy - dy
+
+      if @view && @view[:enabled]
+        scale_w = (@right - @left).to_f / @view[:full_width] / @zoom
+        scale_h = (@top - @bottom).to_f / @view[:full_height] / @zoom
+        left += scale_w * @view[:offset_x]
+        right = left + scale_w * @view[:width]
+        top -= scale_h * @view[:offset_y]
+        bottom = top - scale_h * @view[:height]
+      end
+
+      @projection_matrix.make_orthographic(left, right, top, bottom, @near, @far)
+      @projection_matrix_inverse.copy(@projection_matrix).invert
+      mark_dirty!(:camera)
+      self
+    end
+  end
+end

data/lib/three/cameras/perspective_camera.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require_relative "../math/math_utils"
+require_relative "camera"
+
+module Three
+  class PerspectiveCamera < Camera
+    attr_reader :fov, :zoom, :near, :far, :focus, :aspect, :film_gauge, :film_offset
+    attr_reader :view
+
+    def initialize(fov = 50, aspect: 1, near: 0.1, far: 2000)
+      super()
+      @type = "PerspectiveCamera"
+      @fov = fov
+      @zoom = 1
+      @near = near
+      @far = far
+      @focus = 10
+      @aspect = aspect
+      @view = nil
+      @film_gauge = 35
+      @film_offset = 0
+      update_projection_matrix
+    end
+
+    def fov=(value)
+      @fov = value
+      mark_dirty!(:camera)
+    end
+
+    def zoom=(value)
+      @zoom = value
+      mark_dirty!(:camera)
+    end
+
+    def near=(value)
+      @near = value
+      mark_dirty!(:camera)
+    end
+
+    def far=(value)
+      @far = value
+      mark_dirty!(:camera)
+    end
+
+    def focus=(value)
+      @focus = value
+      mark_dirty!(:camera)
+    end
+
+    def aspect=(value)
+      @aspect = value
+      mark_dirty!(:camera)
+    end
+
+    def film_gauge=(value)
+      @film_gauge = value
+      mark_dirty!(:camera)
+    end
+
+    def film_offset=(value)
+      @film_offset = value
+      mark_dirty!(:camera)
+    end
+
+    def set_focal_length(focal_length)
+      vertical_extent_slope = 0.5 * film_height / focal_length
+      @fov = MathUtils.rad_to_deg(2 * Math.atan(vertical_extent_slope))
+      mark_dirty!(:camera)
+      update_projection_matrix
+      self
+    end
+
+    def focal_length
+      vertical_extent_slope = Math.tan(MathUtils.deg_to_rad(0.5 * @fov))
+      0.5 * film_height / vertical_extent_slope
+    end
+
+    def effective_fov
+      MathUtils.rad_to_deg(2 * Math.atan(Math.tan(MathUtils.deg_to_rad(0.5 * @fov)) / @zoom))
+    end
+
+    def film_width
+      @film_gauge * [@aspect, 1].min
+    end
+
+    def film_height
+      @film_gauge / [@aspect, 1].max
+    end
+
+    def set_view_offset(full_width, full_height, x, y, width, height)
+      @aspect = full_width.to_f / full_height
+      @view = {
+        enabled: true,
+        full_width: full_width,
+        full_height: full_height,
+        offset_x: x,
+        offset_y: y,
+        width: width,
+        height: height
+      }
+      mark_dirty!(:camera)
+      update_projection_matrix
+      self
+    end
+
+    def clear_view_offset
+      @view[:enabled] = false if @view
+      mark_dirty!(:camera)
+      update_projection_matrix
+      self
+    end
+
+    def update_projection_matrix
+      top = @near * Math.tan(MathUtils.deg_to_rad(0.5 * @fov)) / @zoom
+      height = 2 * top
+      width = @aspect * height
+      left = -0.5 * width
+
+      if @view && @view[:enabled]
+        full_width = @view[:full_width]
+        full_height = @view[:full_height]
+        left += @view[:offset_x] * width / full_width
+        top -= @view[:offset_y] * height / full_height
+        width *= @view[:width].to_f / full_width
+        height *= @view[:height].to_f / full_height
+      end
+
+      left += @near * @film_offset / film_width unless @film_offset.zero?
+
+      @projection_matrix.make_perspective(left, left + width, top, top - height, @near, @far)
+      @projection_matrix_inverse.copy(@projection_matrix).invert
+      mark_dirty!(:camera)
+      self
+    end
+  end
+end

data/lib/three/constants.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Three
+  FrontSide = 0
+  BackSide = 1
+  DoubleSide = 2
+
+  NoBlending = 0
+  NormalBlending = 1
+
+  RepeatWrapping = 1000
+  ClampToEdgeWrapping = 1001
+  MirroredRepeatWrapping = 1002
+
+  NearestFilter = 1003
+  NearestMipmapNearestFilter = 1004
+  NearestMipMapNearestFilter = 1004
+  NearestMipmapLinearFilter = 1005
+  NearestMipMapLinearFilter = 1005
+  LinearFilter = 1006
+  LinearMipmapNearestFilter = 1007
+  LinearMipMapNearestFilter = 1007
+  LinearMipmapLinearFilter = 1008
+  LinearMipMapLinearFilter = 1008
+
+  UVMapping = 300
+  CubeReflectionMapping = 301
+  CubeRefractionMapping = 302
+  EquirectangularReflectionMapping = 303
+  EquirectangularRefractionMapping = 304
+
+  NoColorSpace = ""
+  SRGBColorSpace = "srgb"
+  LinearSRGBColorSpace = "srgb-linear"
+
+  BasicShadowMap = 0
+  PCFShadowMap = 1
+  PCFSoftShadowMap = 2
+  VSMShadowMap = 3
+end

data/lib/three/controls/orbit_controls.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative "../backends/threejs"
+require_relative "../math/vector3"
+
+module Three
+  module Controls
+    class OrbitControls
+      PROPERTY_NAMES = {
+        enabled: "enabled",
+        enable_damping: "enableDamping",
+        damping_factor: "dampingFactor",
+        enable_zoom: "enableZoom",
+        zoom_speed: "zoomSpeed",
+        enable_rotate: "enableRotate",
+        rotate_speed: "rotateSpeed",
+        enable_pan: "enablePan",
+        pan_speed: "panSpeed",
+        auto_rotate: "autoRotate",
+        auto_rotate_speed: "autoRotateSpeed",
+        min_distance: "minDistance",
+        max_distance: "maxDistance",
+        min_zoom: "minZoom",
+        max_zoom: "maxZoom"
+      }.freeze
+
+      attr_reader :object, :renderer, :backend, :handle, :dom_element, :target
+      attr_reader(*PROPERTY_NAMES.keys)
+
+      def initialize(object, renderer: nil, dom_element: nil, backend: nil, **parameters)
+        @object = object
+        @renderer = renderer
+        @backend = backend || renderer&.backend || Backends::ThreeJS.new
+        @dom_element = dom_element || default_dom_element(renderer)
+        @target = Vector3.new
+        bind_target_changes
+        set_defaults
+
+        object_handle = @backend.sync(object)
+        @handle = @backend.create_orbit_controls(object_handle, @dom_element)
+        set_values(parameters)
+      end
+
+      def update
+        @backend.update_controls(@handle)
+        @backend.sync_object_transform_from_handle(@object)
+        self
+      end
+
+      def dispose
+        @backend.dispose_controls(@handle)
+        self
+      end
+
+      def target=(value)
+        @target = coerce_vector3(value)
+        bind_target_changes
+        sync_target if @handle
+      end
+
+      PROPERTY_NAMES.each do |ruby_name, js_name|
+        define_method("#{ruby_name}=") do |value|
+          instance_variable_set("@#{ruby_name}", value)
+          @backend.set_control_property(@handle, js_name, value) if @handle
+          value
+        end
+      end
+
+      private
+
+      def set_defaults
+        @enabled = true
+        @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
+        @auto_rotate = false
+        @auto_rotate_speed = 2.0
+        @min_distance = 0
+        @max_distance = Float::INFINITY
+        @min_zoom = 0
+        @max_zoom = Float::INFINITY
+      end
+
+      def set_values(parameters)
+        parameters.each do |key, value|
+          setter = "#{key}="
+          public_send(setter, value) if respond_to?(setter)
+        end
+      end
+
+      def default_dom_element(renderer)
+        return nil unless renderer
+
+        renderer.dom_element
+      end
+
+      def coerce_vector3(value)
+        return value if value.is_a?(Vector3)
+        return Vector3.new(*value) if value.respond_to?(:to_ary)
+
+        raise TypeError, "target must be a Three::Vector3 or an array-like [x, y, z]"
+      end
+
+      def bind_target_changes
+        @target.on_change { sync_target if @handle }
+      end
+
+      def sync_target
+        @backend.set_orbit_controls_target(@handle, @target.to_a)
+      end
+    end
+  end
+end

data/lib/three/core/buffer_attribute.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require_relative "../dirty"
+require_relative "event_dispatcher"
+
+module Three
+  class BufferAttribute < EventDispatcher
+    include Dirty
+
+    @next_id = 0
+
+    class << self
+      attr_accessor :next_id
+    end
+
+    attr_reader :id
+    attr_accessor :name, :array, :item_size, :normalized, :usage, :update_ranges, :version
+    attr_accessor :component_type
+
+    def initialize(array, item_size, normalized = false, component_type: :generic)
+      super()
+      @id = self.class.allocate_id
+      @name = ""
+      @array = array.dup
+      @item_size = item_size
+      @normalized = normalized
+      @usage = :static_draw
+      @update_ranges = []
+      @version = 0
+      @component_type = component_type
+      mark_dirty!
+    end
+
+    def self.allocate_id
+      id = BufferAttribute.next_id
+      BufferAttribute.next_id += 1
+      id
+    end
+
+    def count
+      @array.length / @item_size
+    end
+
+    def needs_update=(value)
+      return unless value
+
+      needs_update!
+    end
+
+    def needs_update!
+      @version += 1
+      mark_dirty!(:array)
+      dispatch_event(:change)
+      self
+    end
+
+    def set_usage(value)
+      @usage = value
+      mark_dirty!(:usage)
+      self
+    end
+
+    def add_update_range(start, count)
+      @update_ranges << { start: start, count: count }
+      mark_dirty!(:update_ranges)
+      self
+    end
+
+    def clear_update_ranges
+      @update_ranges.clear
+      mark_dirty!(:update_ranges)
+      self
+    end
+
+    def copy(source)
+      @name = source.name
+      @array = source.array.dup
+      @item_size = source.item_size
+      @normalized = source.normalized
+      @usage = source.usage
+      @component_type = source.component_type
+      needs_update!
+      self
+    end
+
+    def clone
+      self.class.new(@array, @item_size, @normalized)
+    end
+
+    def get_component(index, component)
+      @array[index * @item_size + component]
+    end
+
+    def set_component(index, component, value)
+      @array[index * @item_size + component] = value
+      needs_update!
+      self
+    end
+
+    def get_x(index)
+      get_component(index, 0)
+    end
+
+    def get_y(index)
+      get_component(index, 1)
+    end
+
+    def get_z(index)
+      get_component(index, 2)
+    end
+
+    def set_x(index, value)
+      set_component(index, 0, value)
+    end
+
+    def set_y(index, value)
+      set_component(index, 1, value)
+    end
+
+    def set_z(index, value)
+      set_component(index, 2, value)
+    end
+
+    def to_h
+      {
+        item_size: @item_size,
+        component_type: @component_type,
+        normalized: @normalized,
+        array: @array.dup
+      }
+    end
+  end
+
+  class Float32BufferAttribute < BufferAttribute
+    def initialize(array, item_size, normalized = false)
+      super(array, item_size, normalized, component_type: :float32)
+    end
+  end
+
+  class Uint16BufferAttribute < BufferAttribute
+    def initialize(array, item_size, normalized = false)
+      super(array, item_size, normalized, component_type: :uint16)
+    end
+  end
+
+  class Uint32BufferAttribute < BufferAttribute
+    def initialize(array, item_size, normalized = false)
+      super(array, item_size, normalized, component_type: :uint32)
+    end
+  end
+end