three-rb 0.1.0

data/lib/three/objects/points.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../core/buffer_geometry"
+require_relative "../materials/points_material"
+require_relative "group"
+
+module Three
+  class Points < Object3D
+    attr_reader :geometry, :material
+
+    def initialize(geometry = BufferGeometry.new, material = PointsMaterial.new)
+      super()
+      @type = "Points"
+      @geometry = nil
+      @material = nil
+      self.geometry = geometry
+      self.material = material
+    end
+
+    def geometry=(value)
+      @geometry.remove_dirty_dependent(self) if @geometry.respond_to?(:remove_dirty_dependent)
+      @geometry = value
+      @geometry.add_dirty_dependent(self) if @geometry.respond_to?(:add_dirty_dependent)
+      mark_dirty!(:points)
+    end
+
+    def material=(value)
+      @material.remove_dirty_dependent(self) if @material.respond_to?(:remove_dirty_dependent)
+      @material = value
+      @material.add_dirty_dependent(self) if @material.respond_to?(:add_dirty_dependent)
+      mark_dirty!(:points)
+    end
+
+    def to_h
+      super.merge(
+        geometry: @geometry.uuid,
+        material: @material.respond_to?(:uuid) ? @material.uuid : nil
+      )
+    end
+  end
+end

data/lib/three/objects/sprite.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "../materials/sprite_material"
+require_relative "../math/vector2"
+require_relative "group"
+
+module Three
+  class Sprite < Object3D
+    attr_reader :material, :center
+
+    def initialize(material = SpriteMaterial.new)
+      super()
+      @type = "Sprite"
+      @material = nil
+      @center = Vector2.new(0.5, 0.5)
+      bind_center_changes
+      self.material = material
+    end
+
+    def material=(value)
+      @material.remove_dirty_dependent(self) if @material.respond_to?(:remove_dirty_dependent)
+      @material = value
+      @material.add_dirty_dependent(self) if @material.respond_to?(:add_dirty_dependent)
+      mark_dirty!(:sprite)
+    end
+
+    def center=(value)
+      @center = coerce_center(value)
+      bind_center_changes
+      mark_dirty!(:sprite)
+    end
+
+    def to_h
+      super.merge(
+        material: @material.respond_to?(:uuid) ? @material.uuid : nil,
+        center: @center.to_a
+      )
+    end
+
+    private
+
+    def coerce_center(value)
+      return value if value.is_a?(Vector2)
+
+      if value.respond_to?(:to_a)
+        array = value.to_a
+        return Vector2.new(array[0], array[1]) if array.length == 2
+      end
+
+      raise TypeError, "center must be a Three::Vector2 or an array-like [x, y]"
+    end
+
+    def bind_center_changes
+      @center.on_change { mark_dirty!(:sprite) }
+    end
+  end
+end

data/lib/three/postprocessing/dot_screen_pass.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "../backends/threejs"
+require_relative "../math/vector2"
+
+module Three
+  module Postprocessing
+    class DotScreenPass
+      PROPERTY_NAMES = {
+        enabled: "enabled"
+      }.freeze
+
+      attr_reader :backend, :handle, :center, :angle, :scale
+      attr_reader(*PROPERTY_NAMES.keys)
+
+      def initialize(center: [0.5, 0.5], angle: 1.57, scale: 1, backend: nil, composer: nil, **parameters)
+        @backend = backend || composer&.backend || Backends::ThreeJS.new
+        @center = coerce_center(center)
+        @angle = angle
+        @scale = scale
+        @enabled = true
+        @handle = @backend.create_dot_screen_pass(@center.to_a, @angle, @scale)
+        bind_center_changes
+        set_values(parameters)
+      end
+
+      PROPERTY_NAMES.each do |ruby_name, js_name|
+        define_method("#{ruby_name}=") do |value|
+          instance_variable_set("@#{ruby_name}", value)
+          @backend.set_postprocessing_pass_property(@handle, js_name, value) if @handle
+          value
+        end
+      end
+
+      def center=(value)
+        @center = coerce_center(value)
+        bind_center_changes
+        sync_uniform("center", @center.to_a)
+        @center
+      end
+
+      def angle=(value)
+        @angle = value
+        sync_uniform("angle", value)
+        value
+      end
+
+      def scale=(value)
+        @scale = value
+        sync_uniform("scale", value)
+        value
+      end
+
+      private
+
+      def coerce_center(value)
+        return value if value.is_a?(Vector2)
+
+        if value.respond_to?(:to_a)
+          array = value.to_a
+          return Vector2.new(array[0], array[1]) if array.length == 2
+        end
+
+        raise TypeError, "center must be a Three::Vector2 or an array-like [x, y]"
+      end
+
+      def bind_center_changes
+        @center.on_change { sync_uniform("center", @center.to_a) }
+      end
+
+      def sync_uniform(name, value)
+        @backend.set_postprocessing_pass_uniform(@handle, name, value) if @handle
+      end
+
+      def set_values(parameters)
+        parameters.each do |key, value|
+          setter = "#{key}="
+          public_send(setter, value) if respond_to?(setter)
+        end
+      end
+    end
+  end
+end

data/lib/three/postprocessing/effect_composer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "../backends/threejs"
+
+module Three
+  module Postprocessing
+    class EffectComposer
+      attr_reader :renderer, :backend, :handle, :passes
+
+      def initialize(renderer:, backend: nil)
+        @renderer = renderer
+        renderer_backend = renderer.backend if renderer.respond_to?(:backend)
+        @backend = backend || renderer_backend
+        raise ArgumentError, "renderer must expose a backend or backend must be provided" unless @backend
+        if renderer_backend && !renderer_backend.equal?(@backend)
+          raise ArgumentError, "effect composer backend must match the renderer backend"
+        end
+
+        @handle = @backend.create_effect_composer(renderer.handle)
+        @passes = []
+      end
+
+      def add_pass(pass)
+        ensure_pass_backend!(pass)
+        @passes << pass
+        @backend.add_effect_composer_pass(@handle, pass.handle)
+        self
+      end
+
+      def set_size(width, height)
+        @backend.set_effect_composer_size(@handle, width, height)
+        self
+      end
+
+      def render(scene = nil, camera = nil)
+        scene.update_matrix_world if scene.respond_to?(:update_matrix_world)
+        camera.update_matrix_world if camera.respond_to?(:update_matrix_world) && camera.parent.nil?
+        @backend.render_effect_composer(@handle, scene, camera)
+        self
+      end
+
+      def dispose
+        @backend.dispose_effect_composer(@handle)
+        self
+      end
+
+      private
+
+      def ensure_pass_backend!(pass)
+        return if pass.respond_to?(:backend) && pass.backend.equal?(@backend)
+
+        raise ArgumentError, "postprocessing pass must use the same backend as the composer"
+      end
+    end
+  end
+end

data/lib/three/postprocessing/output_pass.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../backends/threejs"
+
+module Three
+  module Postprocessing
+    class OutputPass
+      PROPERTY_NAMES = {
+        enabled: "enabled"
+      }.freeze
+
+      attr_reader :backend, :handle
+      attr_reader(*PROPERTY_NAMES.keys)
+
+      def initialize(backend: nil, composer: nil, **parameters)
+        @backend = backend || composer&.backend || Backends::ThreeJS.new
+        @enabled = true
+        @handle = @backend.create_output_pass
+        set_values(parameters)
+      end
+
+      PROPERTY_NAMES.each do |ruby_name, js_name|
+        define_method("#{ruby_name}=") do |value|
+          instance_variable_set("@#{ruby_name}", value)
+          @backend.set_postprocessing_pass_property(@handle, js_name, value) if @handle
+          value
+        end
+      end
+
+      private
+
+      def set_values(parameters)
+        parameters.each do |key, value|
+          setter = "#{key}="
+          public_send(setter, value) if respond_to?(setter)
+        end
+      end
+    end
+  end
+end

data/lib/three/postprocessing/render_pass.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../backends/threejs"
+
+module Three
+  module Postprocessing
+    class RenderPass
+      PROPERTY_NAMES = {
+        enabled: "enabled"
+      }.freeze
+
+      attr_reader :scene, :camera, :backend, :handle
+      attr_reader(*PROPERTY_NAMES.keys)
+
+      def initialize(scene, camera, backend: nil, composer: nil, **parameters)
+        @scene = scene
+        @camera = camera
+        @backend = backend || composer&.backend || Backends::ThreeJS.new
+        @enabled = true
+        @handle = @backend.create_render_pass(scene, camera)
+        set_values(parameters)
+      end
+
+      PROPERTY_NAMES.each do |ruby_name, js_name|
+        define_method("#{ruby_name}=") do |value|
+          instance_variable_set("@#{ruby_name}", value)
+          @backend.set_postprocessing_pass_property(@handle, js_name, value) if @handle
+          value
+        end
+      end
+
+      private
+
+      def set_values(parameters)
+        parameters.each do |key, value|
+          setter = "#{key}="
+          public_send(setter, value) if respond_to?(setter)
+        end
+      end
+    end
+  end
+end

data/lib/three/postprocessing/unreal_bloom_pass.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "../backends/threejs"
+
+module Three
+  module Postprocessing
+    class UnrealBloomPass
+      PROPERTY_NAMES = {
+        enabled: "enabled",
+        strength: "strength",
+        radius: "radius",
+        threshold: "threshold"
+      }.freeze
+
+      attr_reader :backend, :handle, :resolution
+      attr_reader(*PROPERTY_NAMES.keys)
+
+      def initialize(resolution: [1, 1], strength: 1, radius: 0, threshold: 0, backend: nil, composer: nil, **parameters)
+        @backend = backend || composer&.backend || Backends::ThreeJS.new
+        @resolution = coerce_resolution(resolution)
+        @enabled = true
+        @strength = strength
+        @radius = radius
+        @threshold = threshold
+        @handle = @backend.create_unreal_bloom_pass(@resolution, @strength, @radius, @threshold)
+        set_values(parameters)
+      end
+
+      PROPERTY_NAMES.each do |ruby_name, js_name|
+        define_method("#{ruby_name}=") do |value|
+          instance_variable_set("@#{ruby_name}", value)
+          @backend.set_postprocessing_pass_property(@handle, js_name, value) if @handle
+          value
+        end
+      end
+
+      private
+
+      def coerce_resolution(value)
+        if value.respond_to?(:to_a)
+          result = value.to_a
+          return result if result.length == 2
+        end
+
+        raise TypeError, "resolution must be an array-like [width, height]"
+      end
+
+      def set_values(parameters)
+        parameters.each do |key, value|
+          setter = "#{key}="
+          public_send(setter, value) if respond_to?(setter)
+        end
+      end
+    end
+  end
+end

data/lib/three/renderers/renderer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Three
+  module Renderers
+    class Renderer
+      def render(_scene, _camera)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/three/renderers/threejs_renderer.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "../backends/threejs"
+require_relative "renderer"
+
+module Three
+  module Renderers
+    class ThreeJSRenderer < Renderer
+      attr_reader :backend, :handle
+
+      def initialize(canvas: nil, backend: Backends::ThreeJS.new, **options)
+        shadow_map_enabled = options.delete(:shadow_map_enabled)
+        shadow_map_type = options.delete(:shadow_map_type)
+        shadow_map_auto_update = options.delete(:shadow_map_auto_update)
+        @backend = backend
+        @handle = @backend.create_renderer(canvas: canvas, **options)
+        if [shadow_map_enabled, shadow_map_type, shadow_map_auto_update].any?
+          configure_shadow_map(enabled: shadow_map_enabled, type: shadow_map_type, auto_update: shadow_map_auto_update)
+        end
+      end
+
+      def set_size(width, height)
+        @backend.set_renderer_size(@handle, width, height)
+        self
+      end
+
+      def dom_element
+        @backend.renderer_dom_element(@handle)
+      end
+
+      def set_clear_color(color, alpha = 1)
+        @backend.set_clear_color(@handle, color, alpha)
+        self
+      end
+
+      def configure_shadow_map(enabled: nil, type: nil, auto_update: nil)
+        @backend.set_renderer_shadow_map(@handle, enabled: enabled, type: type, auto_update: auto_update)
+        self
+      end
+
+      def animation_loop(&block)
+        @backend.set_animation_loop(@handle, block)
+        self
+      end
+
+      def render(scene, camera)
+        scene.update_matrix_world if scene.respond_to?(:update_matrix_world)
+        camera.update_matrix_world if camera.respond_to?(:update_matrix_world) && camera.parent.nil?
+        @backend.render(@handle, scene, camera)
+        self
+      end
+
+      def dispose(object, **options)
+        @backend.dispose(object, **options)
+        self
+      end
+
+      def traverse_handles(object, &block)
+        return enum_for(:traverse_handles, object) unless block
+
+        @backend.traverse_handles(object, &block)
+        self
+      end
+
+      def dispose_subtree(
+        object,
+        remove: true,
+        dispose_geometries: true,
+        dispose_materials: true,
+        dispose_textures: true,
+        dispose_skeletons: true
+      )
+        @backend.dispose_subtree(
+          object,
+          remove: remove,
+          dispose_geometries: dispose_geometries,
+          dispose_materials: dispose_materials,
+          dispose_textures: dispose_textures,
+          dispose_skeletons: dispose_skeletons
+        )
+        self
+      end
+    end
+  end
+end

data/lib/three/scenes/scene.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../core/object3d"
+
+module Three
+  class Scene < Object3D
+    attr_reader :background, :environment
+    attr_accessor :fog, :override_material
+
+    def initialize
+      super
+      @type = "Scene"
+      @background = nil
+      @environment = nil
+      @fog = nil
+      @override_material = nil
+    end
+
+    def background=(value)
+      @background = value
+      mark_dirty!(:scene)
+    end
+
+    def environment=(value)
+      @environment = value
+      mark_dirty!(:scene)
+    end
+  end
+end

data/lib/three/textures/cube_texture.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "texture"
+
+module Three
+  class CubeTexture < Texture
+    FACE_COUNT = 6
+
+    def initialize(
+      sources,
+      mapping: Three::CubeReflectionMapping,
+      color_space: Three::NoColorSpace,
+      flip_y: false,
+      wrap_s: Three::ClampToEdgeWrapping,
+      wrap_t: Three::ClampToEdgeWrapping,
+      mag_filter: Three::LinearFilter,
+      min_filter: Three::LinearMipmapLinearFilter,
+      offset: nil,
+      repeat: nil,
+      center: nil,
+      rotation: 0,
+      matrix_auto_update: true,
+      matrix: nil
+    )
+      super(
+        validate_sources(sources),
+        mapping: mapping,
+        color_space: color_space,
+        flip_y: flip_y,
+        wrap_s: wrap_s,
+        wrap_t: wrap_t,
+        mag_filter: mag_filter,
+        min_filter: min_filter,
+        offset: offset,
+        repeat: repeat,
+        center: center,
+        rotation: rotation,
+        matrix_auto_update: matrix_auto_update,
+        matrix: matrix
+      )
+    end
+
+    def sources
+      source
+    end
+
+    def sources=(value)
+      self.source = value
+    end
+
+    def source=(value)
+      super(validate_sources(value))
+    end
+
+    def to_h
+      super.merge(type: "CubeTexture", sources: sources)
+    end
+
+    private
+
+    def validate_sources(value)
+      array = value.to_ary if value.respond_to?(:to_ary)
+      array ||= value.to_a if value.respond_to?(:to_a)
+
+      unless array&.length == FACE_COUNT
+        raise ArgumentError, "cube texture sources must contain six image sources"
+      end
+
+      array.dup
+    end
+  end
+end

data/lib/three/textures/rgbe_texture.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "texture"
+
+module Three
+  class RGBETexture < Texture
+    def initialize(
+      source,
+      mapping: Three::EquirectangularReflectionMapping,
+      color_space: Three::LinearSRGBColorSpace,
+      flip_y: true,
+      wrap_s: Three::ClampToEdgeWrapping,
+      wrap_t: Three::ClampToEdgeWrapping,
+      mag_filter: Three::LinearFilter,
+      min_filter: Three::LinearFilter,
+      offset: nil,
+      repeat: nil,
+      center: nil,
+      rotation: 0,
+      matrix_auto_update: true,
+      matrix: nil
+    )
+      super(
+        source,
+        mapping: mapping,
+        color_space: color_space,
+        flip_y: flip_y,
+        wrap_s: wrap_s,
+        wrap_t: wrap_t,
+        mag_filter: mag_filter,
+        min_filter: min_filter,
+        offset: offset,
+        repeat: repeat,
+        center: center,
+        rotation: rotation,
+        matrix_auto_update: matrix_auto_update,
+        matrix: matrix
+      )
+    end
+
+    def to_h
+      super.merge(type: "RGBETexture")
+    end
+  end
+end