three-rb 0.1.0

data/lib/three/core/raycaster.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "../math/vector2"
+require_relative "../math/vector3"
+require_relative "../backends/threejs"
+
+module Three
+  class Raycaster
+    class Intersection
+      attr_reader :distance, :point, :object, :object_handle, :uv, :face_index, :index, :instance_id, :raw
+
+      def initialize(distance:, point:, object:, object_handle:, uv: nil, face_index: nil, index: nil, instance_id: nil, raw: nil)
+        @distance = distance
+        @point = point
+        @object = object
+        @object_handle = object_handle
+        @uv = uv
+        @face_index = face_index
+        @index = index
+        @instance_id = instance_id
+        @raw = raw
+      end
+    end
+
+    attr_reader :backend, :handle
+
+    def initialize(backend: Backends::ThreeJS.new)
+      @backend = backend
+      @handle = @backend.create_raycaster
+    end
+
+    def set_from_camera(coords, camera)
+      @backend.set_raycaster_from_camera(@handle, coerce_vector2(coords), camera)
+      self
+    end
+
+    def intersect_object(object, recursive: false)
+      intersect_objects([object], recursive: recursive)
+    end
+
+    def intersect_objects(objects, recursive: false)
+      @backend.intersect_objects(@handle, objects, recursive: recursive).map do |entry|
+        build_intersection(entry)
+      end
+    end
+
+    private
+
+    def build_intersection(entry)
+      Intersection.new(
+        distance: entry[:distance],
+        point: entry[:point] ? Vector3.new(*entry[:point]) : nil,
+        object: entry[:object],
+        object_handle: entry[:object_handle],
+        uv: entry[:uv] ? Vector2.new(*entry[:uv]) : nil,
+        face_index: entry[:face_index],
+        index: entry[:index],
+        instance_id: entry[:instance_id],
+        raw: entry[:raw]
+      )
+    end
+
+    def coerce_vector2(value)
+      return value.to_a if value.is_a?(Vector2)
+
+      array = value.to_ary if value.respond_to?(:to_ary)
+      array ||= value.to_a if value.respond_to?(:to_a)
+      raise TypeError, "coords must be a Three::Vector2 or an array-like [x, y]" unless array&.length == 2
+
+      array
+    end
+  end
+end

data/lib/three/dirty.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Three
+  module Dirty
+    def dirty?
+      !dirty_fields.empty?
+    end
+
+    def dirty_fields
+      @dirty_fields ||= {}
+    end
+
+    def dirty_field?(field)
+      dirty_fields.key?(:all) || dirty_fields.key?(field)
+    end
+
+    def dirty_dependents
+      @dirty_dependents ||= []
+    end
+
+    def add_dirty_dependent(dependent)
+      dirty_dependents << dependent unless dirty_dependents.include?(dependent)
+      self
+    end
+
+    def remove_dirty_dependent(dependent)
+      dirty_dependents.delete(dependent)
+      self
+    end
+
+    def mark_dirty!(field = :all)
+      dirty_fields[field] = true
+      notify_dirty_dependents(field)
+      self
+    end
+
+    def mark_clean!(*fields)
+      if fields.empty? || fields.include?(:all)
+        dirty_fields.clear
+      else
+        fields.each { |field| dirty_fields.delete(field) }
+      end
+      self
+    end
+
+    private
+
+    def notify_dirty_dependents(field)
+      dirty_dependents.dup.each do |dependent|
+        if dependent.respond_to?(:dirty_dependency_changed)
+          dependent.dirty_dependency_changed(self, field)
+        elsif dependent.respond_to?(:mark_dirty!)
+          dependent.mark_dirty!(:dependency)
+        end
+      end
+    end
+  end
+end

data/lib/three/exporters/three_json_exporter.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Three
+  module Exporters
+    class ThreeJSONExporter
+      FORMAT_VERSION = 1
+
+      def initialize(deterministic_ids: false)
+        @deterministic_ids = deterministic_ids
+      end
+
+      def export(object)
+        raise TypeError, "object must be a Three::Object3D" unless object.is_a?(Object3D)
+
+        reset!
+        {
+          metadata: {
+            version: FORMAT_VERSION,
+            generator: "three-rb",
+            type: "Object"
+          },
+          object: serialize_object(object),
+          geometries: @geometries.values,
+          materials: @materials.values,
+          textures: @textures.values
+        }
+      end
+
+      def to_json(object, *args)
+        export(object).to_json(*args)
+      end
+
+      private
+
+      def reset!
+        @geometries = {}
+        @materials = {}
+        @textures = {}
+        @stable_ids = {}
+        @stable_id_counts = Hash.new(0)
+      end
+
+      def serialize_object(object)
+        data = {
+          uuid: export_id(object, :object),
+          type: object.type,
+          name: object.name,
+          visible: object.visible,
+          layers: object.layers.mask,
+          cast_shadow: object.cast_shadow,
+          receive_shadow: object.receive_shadow,
+          matrix_auto_update: object.matrix_auto_update,
+          position: object.position.to_a,
+          quaternion: object.quaternion.to_a,
+          scale: object.scale.to_a,
+          user_data: object.user_data,
+          children: object.children.map { |child| serialize_object(child) }
+        }
+
+        serialize_scene(object, data) if object.is_a?(Scene)
+        serialize_camera(object, data) if object.is_a?(Camera)
+        serialize_light(object, data) if object.is_a?(Light)
+        serialize_geometry_material_object(object, data) if geometry_material_object?(object)
+        data[:external] = true if object.is_a?(ExternalObject3D)
+
+        data
+      end
+
+      def serialize_scene(scene, data)
+        data[:background] = serialize_texture_reference(scene.background)
+        data[:environment] = serialize_texture_reference(scene.environment)
+      end
+
+      def serialize_camera(camera, data)
+        data[:zoom] = camera.zoom if camera.respond_to?(:zoom)
+
+        case camera
+        when PerspectiveCamera
+          data[:fov] = camera.fov
+          data[:aspect] = camera.aspect
+          data[:near] = camera.near
+          data[:far] = camera.far
+        when OrthographicCamera
+          data[:left] = camera.left
+          data[:right] = camera.right
+          data[:top] = camera.top
+          data[:bottom] = camera.bottom
+          data[:near] = camera.near
+          data[:far] = camera.far
+        end
+      end
+
+      def serialize_light(light, data)
+        data[:color] = light.color.hex
+        data[:intensity] = light.intensity
+        data[:shadow_map_size] = light.shadow_map_size.dup
+        data[:shadow_bias] = light.shadow_bias
+        data[:shadow_normal_bias] = light.shadow_normal_bias
+        data[:shadow_radius] = light.shadow_radius
+        data[:shadow_camera] = light.shadow_camera.dup if light.respond_to?(:shadow_camera)
+        data[:distance] = light.distance if light.respond_to?(:distance)
+        data[:decay] = light.decay if light.respond_to?(:decay)
+        data[:ground_color] = light.ground_color.hex if light.respond_to?(:ground_color)
+      end
+
+      def geometry_material_object?(object)
+        object.is_a?(Mesh) || object.is_a?(Line) || object.is_a?(Points) || object.is_a?(Sprite)
+      end
+
+      def serialize_geometry_material_object(object, data)
+        data[:geometry] = register_geometry(object.geometry) if object.respond_to?(:geometry)
+        data[:material] = register_material(object.material)
+        data[:center] = object.center.to_a if object.is_a?(Sprite)
+
+        return unless object.is_a?(InstancedMesh)
+
+        data[:count] = object.count
+        data[:capacity] = object.capacity
+        data[:instance_matrices] = object.instance_matrices.map(&:to_a)
+        data[:instance_colors] = object.instance_colors&.map(&:to_a)
+      end
+
+      def register_geometry(geometry)
+        return nil unless geometry&.respond_to?(:uuid)
+
+        @geometries[geometry.uuid] ||= serialize_geometry(geometry)
+        export_id(geometry, :geometry)
+      end
+
+      def serialize_geometry(geometry)
+        data = geometry.to_h
+        data[:uuid] = export_id(geometry, :geometry)
+        data[:parameters] = geometry.parameters.dup if geometry.respond_to?(:parameters)
+        data
+      end
+
+      def register_material(material)
+        return material.map { |entry| register_material(entry) } if material.is_a?(Array)
+        return nil unless material&.respond_to?(:uuid)
+
+        @materials[material.uuid] ||= serialize_material(material)
+        export_id(material, :material)
+      end
+
+      def serialize_material(material)
+        data = material.to_h
+        data[:uuid] = export_id(material, :material)
+        material.textures.each { |texture| register_texture(texture) } if material.respond_to?(:textures)
+
+        return data unless material.respond_to?(:texture_slots)
+
+        material.texture_slots.each do |slot|
+          data[slot] = serialize_texture_reference(material.public_send(slot))
+        end
+        data
+      end
+
+      def serialize_texture_reference(texture)
+        return nil unless texture
+        return texture unless texture.respond_to?(:uuid)
+
+        register_texture(texture)
+      end
+
+      def register_texture(texture)
+        @textures[texture.uuid] ||= serialize_texture(texture)
+        export_id(texture, :texture)
+      end
+
+      def serialize_texture(texture)
+        texture.to_h.merge(uuid: export_id(texture, :texture))
+      end
+
+      def export_id(resource, prefix)
+        return resource.uuid unless @deterministic_ids
+
+        @stable_ids[resource.uuid] ||= begin
+          index = @stable_id_counts[prefix]
+          @stable_id_counts[prefix] += 1
+          "#{prefix}-#{index}"
+        end
+      end
+    end
+  end
+end

data/lib/three/geometries/box_geometry.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "../core/buffer_attribute"
+require_relative "../core/buffer_geometry"
+
+module Three
+  class BoxGeometry < BufferGeometry
+    attr_accessor :parameters
+
+    def initialize(width = 1, height = 1, depth = 1, width_segments: 1, height_segments: 1, depth_segments: 1)
+      super()
+      @type = "BoxGeometry"
+      @parameters = {
+        width: width,
+        height: height,
+        depth: depth,
+        width_segments: width_segments,
+        height_segments: height_segments,
+        depth_segments: depth_segments
+      }
+
+      build(width, height, depth, width_segments.floor, height_segments.floor, depth_segments.floor)
+    end
+
+    private
+
+    def build(width, height, depth, width_segments, height_segments, depth_segments)
+      indices = []
+      vertices = []
+      normals = []
+      uvs = []
+      state = { vertex_count: 0, group_start: 0 }
+
+      build_plane(indices, vertices, normals, uvs, state, "z", "y", "x", -1, -1, depth, height, width, depth_segments, height_segments, 0)
+      build_plane(indices, vertices, normals, uvs, state, "z", "y", "x", 1, -1, depth, height, -width, depth_segments, height_segments, 1)
+      build_plane(indices, vertices, normals, uvs, state, "x", "z", "y", 1, 1, width, depth, height, width_segments, depth_segments, 2)
+      build_plane(indices, vertices, normals, uvs, state, "x", "z", "y", 1, -1, width, depth, -height, width_segments, depth_segments, 3)
+      build_plane(indices, vertices, normals, uvs, state, "x", "y", "z", 1, -1, width, height, depth, width_segments, height_segments, 4)
+      build_plane(indices, vertices, normals, uvs, state, "x", "y", "z", -1, -1, width, height, -depth, width_segments, height_segments, 5)
+
+      set_index(indices)
+      set_attribute(:position, Float32BufferAttribute.new(vertices, 3))
+      set_attribute(:normal, Float32BufferAttribute.new(normals, 3))
+      set_attribute(:uv, Float32BufferAttribute.new(uvs, 2))
+    end
+
+    # Plane construction follows three.js BoxGeometry's MIT-licensed algorithm.
+    def build_plane(indices, vertices, normals, uvs, state, u, v, w, udir, vdir, width, height, depth, grid_x, grid_y, material_index)
+      segment_width = width.to_f / grid_x
+      segment_height = height.to_f / grid_y
+      width_half = width / 2.0
+      height_half = height / 2.0
+      depth_half = depth / 2.0
+      grid_x1 = grid_x + 1
+      grid_y1 = grid_y + 1
+      vertex_counter = 0
+      group_count = 0
+
+      grid_y1.times do |iy|
+        y = iy * segment_height - height_half
+
+        grid_x1.times do |ix|
+          x = ix * segment_width - width_half
+          vector = { "x" => 0, "y" => 0, "z" => 0 }
+          vector[u] = x * udir
+          vector[v] = y * vdir
+          vector[w] = depth_half
+          vertices.push(vector["x"], vector["y"], vector["z"])
+
+          vector[u] = 0
+          vector[v] = 0
+          vector[w] = depth.positive? ? 1 : -1
+          normals.push(vector["x"], vector["y"], vector["z"])
+
+          uvs.push(ix.to_f / grid_x, 1 - (iy.to_f / grid_y))
+          vertex_counter += 1
+        end
+      end
+
+      grid_y.times do |iy|
+        grid_x.times do |ix|
+          a = state[:vertex_count] + ix + grid_x1 * iy
+          b = state[:vertex_count] + ix + grid_x1 * (iy + 1)
+          c = state[:vertex_count] + (ix + 1) + grid_x1 * (iy + 1)
+          d = state[:vertex_count] + (ix + 1) + grid_x1 * iy
+
+          indices.push(a, b, d, b, c, d)
+          group_count += 6
+        end
+      end
+
+      add_group(state[:group_start], group_count, material_index)
+      state[:group_start] += group_count
+      state[:vertex_count] += vertex_counter
+    end
+  end
+end

data/lib/three/geometries/plane_geometry.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "../core/buffer_attribute"
+require_relative "../core/buffer_geometry"
+
+module Three
+  class PlaneGeometry < BufferGeometry
+    attr_accessor :parameters
+
+    def initialize(width = 1, height = 1, width_segments: 1, height_segments: 1)
+      super()
+      @type = "PlaneGeometry"
+      @parameters = {
+        width: width,
+        height: height,
+        width_segments: width_segments,
+        height_segments: height_segments
+      }
+
+      build(width, height, width_segments.floor, height_segments.floor)
+    end
+
+    private
+
+    # Plane construction follows three.js PlaneGeometry's MIT-licensed algorithm.
+    def build(width, height, width_segments, height_segments)
+      width_half = width / 2.0
+      height_half = height / 2.0
+      grid_x = width_segments
+      grid_y = height_segments
+      grid_x1 = grid_x + 1
+      grid_y1 = grid_y + 1
+      segment_width = width.to_f / grid_x
+      segment_height = height.to_f / grid_y
+
+      indices = []
+      vertices = []
+      normals = []
+      uvs = []
+
+      grid_y1.times do |iy|
+        y = iy * segment_height - height_half
+
+        grid_x1.times do |ix|
+          x = ix * segment_width - width_half
+
+          vertices.push(x, -y, 0)
+          normals.push(0, 0, 1)
+          uvs.push(ix.to_f / grid_x, 1 - (iy.to_f / grid_y))
+        end
+      end
+
+      grid_y.times do |iy|
+        grid_x.times do |ix|
+          a = ix + grid_x1 * iy
+          b = ix + grid_x1 * (iy + 1)
+          c = (ix + 1) + grid_x1 * (iy + 1)
+          d = (ix + 1) + grid_x1 * iy
+
+          indices.push(a, b, d, b, c, d)
+        end
+      end
+
+      set_index(indices)
+      set_attribute(:position, Float32BufferAttribute.new(vertices, 3))
+      set_attribute(:normal, Float32BufferAttribute.new(normals, 3))
+      set_attribute(:uv, Float32BufferAttribute.new(uvs, 2))
+    end
+  end
+end

data/lib/three/geometries/sphere_geometry.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "../core/buffer_attribute"
+require_relative "../core/buffer_geometry"
+
+module Three
+  class SphereGeometry < BufferGeometry
+    attr_accessor :parameters
+
+    def initialize(radius = 1, width_segments: 32, height_segments: 16, phi_start: 0, phi_length: Math::PI * 2, theta_start: 0, theta_length: Math::PI)
+      super()
+      @type = "SphereGeometry"
+      @parameters = {
+        radius: radius,
+        width_segments: width_segments,
+        height_segments: height_segments,
+        phi_start: phi_start,
+        phi_length: phi_length,
+        theta_start: theta_start,
+        theta_length: theta_length
+      }
+
+      build(
+        radius,
+        [3, width_segments.floor].max,
+        [2, height_segments.floor].max,
+        phi_start,
+        phi_length,
+        theta_start,
+        theta_length
+      )
+    end
+
+    private
+
+    # Sphere construction follows three.js SphereGeometry's MIT-licensed algorithm.
+    def build(radius, width_segments, height_segments, phi_start, phi_length, theta_start, theta_length)
+      theta_end = [theta_start + theta_length, Math::PI].min
+      index = 0
+      grid = []
+      indices = []
+      vertices = []
+      normals = []
+      uvs = []
+
+      (height_segments + 1).times do |iy|
+        vertices_row = []
+        v = iy.to_f / height_segments
+        u_offset = uv_offset(iy, height_segments, width_segments, theta_start, theta_end)
+
+        (width_segments + 1).times do |ix|
+          u = ix.to_f / width_segments
+          theta = theta_start + v * theta_length
+          phi = phi_start + u * phi_length
+
+          x = -radius * Math.cos(phi) * Math.sin(theta)
+          y = radius * Math.cos(theta)
+          z = radius * Math.sin(phi) * Math.sin(theta)
+
+          vertices.push(x, y, z)
+          push_normal(normals, x, y, z)
+          uvs.push(u + u_offset, 1 - v)
+          vertices_row << index
+          index += 1
+        end
+
+        grid << vertices_row
+      end
+
+      height_segments.times do |iy|
+        width_segments.times do |ix|
+          a = grid[iy][ix + 1]
+          b = grid[iy][ix]
+          c = grid[iy + 1][ix]
+          d = grid[iy + 1][ix + 1]
+
+          indices.push(a, b, d) if iy != 0 || theta_start.positive?
+          indices.push(b, c, d) if iy != height_segments - 1 || theta_end < Math::PI
+        end
+      end
+
+      set_index(indices)
+      set_attribute(:position, Float32BufferAttribute.new(vertices, 3))
+      set_attribute(:normal, Float32BufferAttribute.new(normals, 3))
+      set_attribute(:uv, Float32BufferAttribute.new(uvs, 2))
+    end
+
+    def uv_offset(iy, height_segments, width_segments, theta_start, theta_end)
+      if iy.zero? && theta_start.zero?
+        0.5 / width_segments
+      elsif iy == height_segments && theta_end == Math::PI
+        -0.5 / width_segments
+      else
+        0
+      end
+    end
+
+    def push_normal(normals, x, y, z)
+      length = Math.sqrt((x * x) + (y * y) + (z * z))
+      if length.zero?
+        normals.push(0, 0, 0)
+      else
+        normals.push(x / length, y / length, z / length)
+      end
+    end
+  end
+end

data/lib/three/lights/ambient_light.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "light"
+
+module Three
+  class AmbientLight < Light
+    def initialize(color = 0xffffff, intensity = 1)
+      super
+      @type = "AmbientLight"
+    end
+  end
+end

data/lib/three/lights/directional_light.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "light"
+
+module Three
+  class DirectionalLight < Light
+    attr_reader :shadow_camera
+
+    def initialize(color = 0xffffff, intensity = 1)
+      super
+      @type = "DirectionalLight"
+      @position.copy(Object3D::DEFAULT_UP)
+      @shadow_camera = {
+        left: -5,
+        right: 5,
+        top: 5,
+        bottom: -5,
+        near: 0.5,
+        far: 500
+      }
+    end
+
+    def set_shadow_camera(left: nil, right: nil, top: nil, bottom: nil, near: nil, far: nil)
+      @shadow_camera[:left] = left unless left.nil?
+      @shadow_camera[:right] = right unless right.nil?
+      @shadow_camera[:top] = top unless top.nil?
+      @shadow_camera[:bottom] = bottom unless bottom.nil?
+      @shadow_camera[:near] = near unless near.nil?
+      @shadow_camera[:far] = far unless far.nil?
+      mark_dirty!(:shadow)
+      self
+    end
+
+    def to_h
+      super.merge(shadow_camera: @shadow_camera.dup)
+    end
+  end
+end

data/lib/three/lights/hemisphere_light.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "light"
+
+module Three
+  class HemisphereLight < Light
+    attr_reader :ground_color
+
+    def initialize(sky_color = 0xffffff, ground_color = 0xffffff, intensity = 1)
+      super(sky_color, intensity)
+      @type = "HemisphereLight"
+      @ground_color = Color.new(ground_color)
+      bind_ground_color_changes
+    end
+
+    def ground_color=(value)
+      @ground_color = value.is_a?(Color) ? value : Color.new(value)
+      bind_ground_color_changes
+      mark_dirty!(:light)
+    end
+
+    def to_h
+      super.merge(
+        ground_color: @ground_color.hex
+      )
+    end
+
+    private
+
+    def bind_ground_color_changes
+      @ground_color.on_change { mark_dirty!(:light) }
+    end
+  end
+end