three-rb 0.1.0

data/lib/three/lights/light.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "../core/object3d"
+require_relative "../math/color"
+
+module Three
+  class Light < Object3D
+    attr_reader :color, :intensity
+    attr_reader :shadow_map_size, :shadow_bias, :shadow_normal_bias, :shadow_radius
+
+    def initialize(color = 0xffffff, intensity = 1)
+      super()
+      @type = "Light"
+      @color = Color.new(color)
+      @intensity = intensity
+      @shadow_map_size = [512, 512]
+      @shadow_bias = 0
+      @shadow_normal_bias = 0
+      @shadow_radius = 1
+      bind_color_changes
+      mark_dirty!(:light)
+    end
+
+    def color=(value)
+      @color = value.is_a?(Color) ? value : Color.new(value)
+      bind_color_changes
+      mark_dirty!(:light)
+    end
+
+    def intensity=(value)
+      @intensity = value
+      mark_dirty!(:light)
+    end
+
+    def shadow_map_size=(value)
+      array = coerce_shadow_map_size(value)
+      @shadow_map_size = array
+      mark_dirty!(:shadow)
+    end
+
+    def shadow_bias=(value)
+      @shadow_bias = value
+      mark_dirty!(:shadow)
+    end
+
+    def shadow_normal_bias=(value)
+      @shadow_normal_bias = value
+      mark_dirty!(:shadow)
+    end
+
+    def shadow_radius=(value)
+      @shadow_radius = value
+      mark_dirty!(:shadow)
+    end
+
+    def dispose
+      dispatch_event(:dispose)
+    end
+
+    def to_h
+      super.merge(
+        color: @color.hex,
+        intensity: @intensity,
+        shadow_map_size: @shadow_map_size.dup,
+        shadow_bias: @shadow_bias,
+        shadow_normal_bias: @shadow_normal_bias,
+        shadow_radius: @shadow_radius
+      )
+    end
+
+    private
+
+    def bind_color_changes
+      @color.on_change { mark_dirty!(:light) }
+    end
+
+    def coerce_shadow_map_size(value)
+      array = value.to_ary if value.respond_to?(:to_ary)
+      array ||= value.to_a if value.respond_to?(:to_a)
+      raise TypeError, "shadow_map_size must be array-like [width, height]" unless array && array.length >= 2
+
+      [array[0], array[1]]
+    end
+  end
+end

data/lib/three/lights/point_light.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "light"
+
+module Three
+  class PointLight < Light
+    attr_reader :distance, :decay
+
+    def initialize(color = 0xffffff, intensity = 1, distance = 0, decay = 2)
+      super(color, intensity)
+      @type = "PointLight"
+      @distance = distance
+      @decay = decay
+    end
+
+    def distance=(value)
+      @distance = value
+      mark_dirty!(:light)
+    end
+
+    def decay=(value)
+      @decay = value
+      mark_dirty!(:light)
+    end
+
+    def to_h
+      super.merge(
+        distance: @distance,
+        decay: @decay
+      )
+    end
+  end
+end

data/lib/three/loaders/cube_texture_loader.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "../textures/cube_texture"
+
+module Three
+  module Loaders
+    class CubeTextureLoader
+      def load(sources)
+        CubeTexture.new(sources)
+      end
+    end
+  end
+end

data/lib/three/loaders/gltf_loader.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../backends/threejs"
+require_relative "../animation/animation_clip"
+require_relative "../objects/external_object3d"
+
+module Three
+  module Loaders
+    class GLTF
+      attr_reader :handle, :scene, :animations
+
+      def initialize(handle, adapter:)
+        @handle = handle
+        @adapter = adapter
+        @scene = ExternalObject3D.new(read_property(handle, :scene), type: "GLTFScene")
+        @animations = @adapter.gltf_animations(handle).map do |animation|
+          AnimationClip.new(animation, adapter: @adapter)
+        end
+      end
+
+      private
+
+      def read_property(object, name)
+        object[name]
+      end
+    end
+
+    class GLTFLoader
+      def initialize(adapter: nil, backend: nil, draco_decoder_path: nil, draco_decoder_config: nil)
+        @adapter = adapter || backend&.adapter || Backends::ThreeJS::RubyWasmAdapter.new
+        @draco_decoder_path = draco_decoder_path
+        @draco_decoder_config = draco_decoder_config
+      end
+
+      def load(source)
+        result = @adapter.load_gltf(
+          source,
+          draco_decoder_path: @draco_decoder_path,
+          draco_decoder_config: @draco_decoder_config
+        )
+        result = result.await if result.respond_to?(:await)
+        gltf = GLTF.new(result, adapter: @adapter)
+        yield gltf if block_given?
+        gltf
+      end
+    end
+  end
+end

data/lib/three/loaders/rgbe_loader.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "../textures/rgbe_texture"
+
+module Three
+  module Loaders
+    class RGBELoader
+      def load(source, **parameters)
+        texture = RGBETexture.new(source, **parameters)
+        yield texture if block_given?
+        texture
+      end
+    end
+  end
+end

data/lib/three/loaders/texture_loader.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "../textures/texture"
+
+module Three
+  module Loaders
+    class TextureLoader
+      def load(source)
+        Texture.new(source)
+      end
+    end
+  end
+end

data/lib/three/loaders/three_json_loader.rb

@@ -0,0 +1,409 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Three
+  module Loaders
+    class ThreeJSONLoader
+      def parse(input)
+        data = input.is_a?(String) ? JSON.parse(input) : input
+        @textures = build_resource_map(value(data, :textures)) { |entry| build_texture(entry) }
+        @geometries = build_resource_map(value(data, :geometries)) { |entry| build_geometry(entry) }
+        @materials = build_resource_map(value(data, :materials)) { |entry| build_material(entry) }
+        build_object(value(data, :object))
+      end
+
+      private
+
+      def build_resource_map(entries)
+        Array(entries).each_with_object({}) do |entry, result|
+          result[value(entry, :uuid)] = yield(entry)
+        end
+      end
+
+      def build_texture(entry)
+        case value(entry, :type)
+        when "CubeTexture"
+          CubeTexture.new(
+            value(entry, :sources) || value(entry, :source),
+            **texture_parameters(entry)
+          )
+        when "RGBETexture"
+          RGBETexture.new(value(entry, :source), **texture_parameters(entry))
+        else
+          Texture.new(value(entry, :source), **texture_parameters(entry))
+        end
+      end
+
+      def texture_parameters(entry)
+        {
+          mapping: value(entry, :mapping),
+          color_space: value(entry, :color_space),
+          flip_y: value(entry, :flip_y),
+          wrap_s: value(entry, :wrap_s),
+          wrap_t: value(entry, :wrap_t),
+          mag_filter: value(entry, :mag_filter),
+          min_filter: value(entry, :min_filter),
+          offset: value(entry, :offset),
+          repeat: value(entry, :repeat),
+          center: value(entry, :center),
+          rotation: value(entry, :rotation),
+          matrix_auto_update: value(entry, :matrix_auto_update),
+          matrix: value(entry, :matrix)
+        }.compact
+      end
+
+      def build_geometry(entry)
+        case value(entry, :type)
+        when "BoxGeometry"
+          parameters = value(entry, :parameters) || {}
+          BoxGeometry.new(
+            value(parameters, :width) || 1,
+            value(parameters, :height) || 1,
+            value(parameters, :depth) || 1,
+            width_segments: value(parameters, :width_segments) || 1,
+            height_segments: value(parameters, :height_segments) || 1,
+            depth_segments: value(parameters, :depth_segments) || 1
+          )
+        when "PlaneGeometry"
+          parameters = value(entry, :parameters) || {}
+          PlaneGeometry.new(
+            value(parameters, :width) || 1,
+            value(parameters, :height) || 1,
+            width_segments: value(parameters, :width_segments) || 1,
+            height_segments: value(parameters, :height_segments) || 1
+          )
+        when "SphereGeometry"
+          parameters = value(entry, :parameters) || {}
+          SphereGeometry.new(
+            value(parameters, :radius) || 1,
+            width_segments: value(parameters, :width_segments) || 32,
+            height_segments: value(parameters, :height_segments) || 16,
+            phi_start: value(parameters, :phi_start) || 0,
+            phi_length: value(parameters, :phi_length) || Math::PI * 2,
+            theta_start: value(parameters, :theta_start) || 0,
+            theta_length: value(parameters, :theta_length) || Math::PI
+          )
+        else
+          build_buffer_geometry(entry)
+        end
+      end
+
+      def build_buffer_geometry(entry)
+        geometry = BufferGeometry.new
+        geometry.name = value(entry, :name) if value(entry, :name)
+        geometry.set_index(build_buffer_attribute(value(entry, :index))) if value(entry, :index)
+
+        (value(entry, :attributes) || {}).each do |name, attribute_entry|
+          geometry.set_attribute(name.to_sym, build_buffer_attribute(attribute_entry))
+        end
+
+        Array(value(entry, :groups)).each do |group|
+          geometry.add_group(
+            value(group, :start),
+            value(group, :count),
+            value(group, :material_index) || 0
+          )
+        end
+
+        geometry
+      end
+
+      def build_buffer_attribute(entry)
+        component_type = (value(entry, :component_type) || :generic).to_sym
+        array = value(entry, :array) || []
+        item_size = value(entry, :item_size)
+        normalized = value(entry, :normalized) || false
+
+        case component_type
+        when :float32
+          Float32BufferAttribute.new(array, item_size, normalized)
+        when :uint16
+          Uint16BufferAttribute.new(array, item_size, normalized)
+        when :uint32
+          Uint32BufferAttribute.new(array, item_size, normalized)
+        else
+          BufferAttribute.new(array, item_size, normalized, component_type: component_type)
+        end
+      end
+
+      def build_material(entry)
+        parameters = material_parameters(entry)
+        case value(entry, :type)
+        when "MeshBasicMaterial"
+          MeshBasicMaterial.new(parameters)
+        when "LineBasicMaterial"
+          LineBasicMaterial.new(parameters)
+        when "MeshLambertMaterial"
+          MeshLambertMaterial.new(parameters)
+        when "MeshMatcapMaterial"
+          MeshMatcapMaterial.new(parameters)
+        when "MeshNormalMaterial"
+          MeshNormalMaterial.new(parameters)
+        when "MeshPhongMaterial"
+          MeshPhongMaterial.new(parameters)
+        when "MeshPhysicalMaterial"
+          MeshPhysicalMaterial.new(parameters)
+        when "MeshStandardMaterial"
+          MeshStandardMaterial.new(parameters)
+        when "MeshToonMaterial"
+          MeshToonMaterial.new(parameters)
+        when "PointsMaterial"
+          PointsMaterial.new(parameters)
+        when "ShadowMaterial"
+          ShadowMaterial.new(parameters)
+        when "SpriteMaterial"
+          SpriteMaterial.new(parameters)
+        else
+          Material.new(parameters)
+        end
+      end
+
+      def material_parameters(entry)
+        parameters = {}
+        %i[
+          name
+          side
+          opacity
+          transparent
+          visible
+          vertex_colors
+          color
+          emissive
+          specular
+          shininess
+          roughness
+          metalness
+          anisotropy
+          anisotropy_rotation
+          clearcoat
+          clearcoat_roughness
+          transmission
+          thickness
+          ior
+          reflectivity
+          iridescence
+          iridescence_ior
+          iridescence_thickness_range
+          sheen
+          sheen_color
+          sheen_roughness
+          dispersion
+          specular_intensity
+          specular_color
+          attenuation_distance
+          attenuation_color
+          wireframe
+          wireframe_linewidth
+          linewidth
+          linecap
+          linejoin
+          fog
+          flat_shading
+          rotation
+          size
+          size_attenuation
+        ].each do |key|
+          next unless has_value?(entry, key)
+
+          parameters[key] = value(entry, key)
+        end
+
+        texture_slots(entry).each do |slot|
+          uuid = value(entry, slot)
+          parameters[slot] = @textures[uuid] if uuid
+        end
+        parameters
+      end
+
+      def texture_slots(entry)
+        %i[
+          map
+          alpha_map
+          ao_map
+          bump_map
+          displacement_map
+          emissive_map
+          env_map
+          gradient_map
+          light_map
+          matcap
+          metalness_map
+          normal_map
+          roughness_map
+          specular_map
+          anisotropy_map
+          clearcoat_map
+          clearcoat_normal_map
+          clearcoat_roughness_map
+          transmission_map
+          thickness_map
+          iridescence_map
+          iridescence_thickness_map
+          sheen_color_map
+          sheen_roughness_map
+          specular_color_map
+          specular_intensity_map
+        ].select { |slot| has_value?(entry, slot) }
+      end
+
+      def build_object(entry)
+        object = instantiate_object(entry)
+        apply_object_properties(object, entry)
+        Array(value(entry, :children)).each { |child| object.add(build_object(child)) }
+        object
+      end
+
+      def instantiate_object(entry)
+        case value(entry, :type)
+        when "Scene"
+          build_scene(entry)
+        when "PerspectiveCamera"
+          PerspectiveCamera.new(
+            value(entry, :fov) || 50,
+            aspect: value(entry, :aspect) || 1,
+            near: value(entry, :near) || 0.1,
+            far: value(entry, :far) || 2000
+          )
+        when "OrthographicCamera"
+          OrthographicCamera.new(
+            value(entry, :left),
+            value(entry, :right),
+            value(entry, :top),
+            value(entry, :bottom),
+            near: value(entry, :near) || 0.1,
+            far: value(entry, :far) || 2000
+          )
+        when "AmbientLight"
+          AmbientLight.new(value(entry, :color) || 0xffffff, value(entry, :intensity) || 1)
+        when "DirectionalLight"
+          build_directional_light(entry)
+        when "PointLight"
+          PointLight.new(
+            value(entry, :color) || 0xffffff,
+            value(entry, :intensity) || 1,
+            value(entry, :distance) || 0,
+            value(entry, :decay) || 2
+          )
+        when "HemisphereLight"
+          HemisphereLight.new(
+            value(entry, :color) || 0xffffff,
+            value(entry, :ground_color) || 0xffffff,
+            value(entry, :intensity) || 1
+          )
+        when "InstancedMesh"
+          build_instanced_mesh(entry)
+        when "Mesh"
+          Mesh.new(@geometries[value(entry, :geometry)], material_reference(entry))
+        when "Line"
+          Line.new(@geometries[value(entry, :geometry)], material_reference(entry))
+        when "Points"
+          Points.new(@geometries[value(entry, :geometry)], material_reference(entry))
+        when "Sprite"
+          build_sprite(entry)
+        when "Group"
+          Group.new
+        else
+          Object3D.new
+        end
+      end
+
+      def build_scene(entry)
+        scene = Scene.new
+        scene.background = @textures[value(entry, :background)] if value(entry, :background)
+        scene.environment = @textures[value(entry, :environment)] if value(entry, :environment)
+        scene
+      end
+
+      def build_directional_light(entry)
+        light = DirectionalLight.new(value(entry, :color) || 0xffffff, value(entry, :intensity) || 1)
+        camera = value(entry, :shadow_camera)
+        light.set_shadow_camera(**symbolize_keys(camera)) if camera
+        light
+      end
+
+      def build_instanced_mesh(entry)
+        mesh = InstancedMesh.new(
+          @geometries[value(entry, :geometry)],
+          material_reference(entry),
+          value(entry, :capacity) || value(entry, :count) || 1
+        )
+        mesh.count = value(entry, :count) if has_value?(entry, :count)
+
+        Array(value(entry, :instance_matrices)).each_with_index do |matrix, index|
+          mesh.set_matrix_at(index, matrix)
+        end
+        Array(value(entry, :instance_colors)).each_with_index do |color, index|
+          mesh.set_color_at(index, color) if color
+        end
+        mesh
+      end
+
+      def build_sprite(entry)
+        sprite = Sprite.new(material_reference(entry))
+        sprite.center = value(entry, :center) if value(entry, :center)
+        sprite
+      end
+
+      def material_reference(entry)
+        material = value(entry, :material)
+        return material.map { |uuid| @materials[uuid] } if material.is_a?(Array)
+
+        @materials[material]
+      end
+
+      def apply_object_properties(object, entry)
+        object.name = value(entry, :name) if has_value?(entry, :name)
+        object.visible = value(entry, :visible) if has_value?(entry, :visible)
+        object.layers.mask = value(entry, :layers) if has_value?(entry, :layers)
+        object.cast_shadow = value(entry, :cast_shadow) if has_value?(entry, :cast_shadow)
+        object.receive_shadow = value(entry, :receive_shadow) if has_value?(entry, :receive_shadow)
+        object.matrix_auto_update = value(entry, :matrix_auto_update) if has_value?(entry, :matrix_auto_update)
+        object.user_data = value(entry, :user_data) || {}
+
+        object.position.set(*value(entry, :position)) if value(entry, :position)
+        object.quaternion.set(*value(entry, :quaternion)) if value(entry, :quaternion)
+        object.scale.set(*value(entry, :scale)) if value(entry, :scale)
+
+        apply_camera_properties(object, entry)
+        apply_light_properties(object, entry)
+        object
+      end
+
+      def apply_camera_properties(object, entry)
+        return unless object.is_a?(Camera)
+
+        object.zoom = value(entry, :zoom) if has_value?(entry, :zoom)
+        object.update_projection_matrix if object.respond_to?(:update_projection_matrix)
+      end
+
+      def apply_light_properties(object, entry)
+        return unless object.is_a?(Light)
+
+        object.shadow_map_size = value(entry, :shadow_map_size) if value(entry, :shadow_map_size)
+        object.shadow_bias = value(entry, :shadow_bias) if has_value?(entry, :shadow_bias)
+        object.shadow_normal_bias = value(entry, :shadow_normal_bias) if has_value?(entry, :shadow_normal_bias)
+        object.shadow_radius = value(entry, :shadow_radius) if has_value?(entry, :shadow_radius)
+      end
+
+      def has_value?(hash, key)
+        hash.key?(key) || hash.key?(key.to_s)
+      end
+
+      def value(hash, key)
+        return nil unless hash
+        return hash[key] if hash.key?(key)
+
+        hash[key.to_s]
+      end
+
+      def symbolize_keys(hash)
+        return {} unless hash
+
+        hash.each_with_object({}) do |(key, value), result|
+          result[key.to_sym] = value
+        end
+      end
+    end
+  end
+end

data/lib/three/materials/line_basic_material.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "../math/color"
+require_relative "material"
+
+module Three
+  class LineBasicMaterial < Material
+    attr_reader :color, :linewidth, :linecap, :linejoin, :fog
+
+    def initialize(parameters = nil)
+      super(nil)
+      @type = "LineBasicMaterial"
+      @color = Color.new(0xffffff)
+      @linewidth = 1
+      @linecap = "round"
+      @linejoin = "round"
+      @fog = true
+      bind_color_changes
+      set_values(parameters) if parameters
+      mark_dirty!
+    end
+
+    def color=(value)
+      @color = value.is_a?(Color) ? value : Color.new(value)
+      bind_color_changes
+      mark_dirty!(:parameters)
+    end
+
+    def linewidth=(value)
+      @linewidth = value
+      mark_dirty!(:parameters)
+    end
+
+    def linecap=(value)
+      @linecap = value
+      mark_dirty!(:parameters)
+    end
+
+    def linejoin=(value)
+      @linejoin = value
+      mark_dirty!(:parameters)
+    end
+
+    def fog=(value)
+      @fog = value
+      mark_dirty!(:parameters)
+    end
+
+    def to_h
+      super.merge(
+        color: @color.hex,
+        linewidth: @linewidth,
+        linecap: @linecap,
+        linejoin: @linejoin,
+        fog: @fog
+      )
+    end
+
+    private
+
+    def bind_color_changes
+      @color.on_change { mark_dirty!(:parameters) }
+    end
+  end
+end