three-rb 0.1.0 → 0.2.0

data/lib/three/browser.rb

@@ -0,0 +1,389 @@
+# frozen_string_literal: true
+
+module Three
+  module Browser
+    class Error < RuntimeError; end
+
+    class Element
+      attr_reader :handle
+
+      def initialize(handle)
+        @handle = handle
+      end
+
+      def self.wrap(value)
+        value.is_a?(self) ? value : new(value)
+      end
+
+      def client_width
+        [@handle[:clientWidth].to_i, 1].max
+      end
+
+      def client_height
+        [@handle[:clientHeight].to_i, 1].max
+      end
+
+      def size
+        [client_width, client_height]
+      end
+
+      def add_event_listener(name, &block)
+        @handle.call(:addEventListener, name.to_s, block)
+        self
+      end
+
+      alias on add_event_listener
+
+      def bounding_client_rect
+        rect = @handle.call(:getBoundingClientRect)
+        {
+          left: rect[:left].to_f,
+          top: rect[:top].to_f,
+          width: rect[:width].to_f,
+          height: rect[:height].to_f
+        }
+      end
+
+      def pointer_ndc(event)
+        rect = bounding_client_rect
+        x = ((event[:clientX].to_f - rect[:left]) / rect[:width]) * 2 - 1
+        y = -(((event[:clientY].to_f - rect[:top]) / rect[:height]) * 2 - 1)
+        [x, y]
+      end
+    end
+
+    class Storage
+      attr_reader :handle
+
+      def initialize(handle)
+        @handle = handle
+      end
+
+      def set(key, value)
+        @handle.call(:setItem, key.to_s, value)
+        self
+      end
+
+      def get(key)
+        @handle.call(:getItem, key.to_s)
+      end
+
+      def delete(key)
+        @handle.call(:removeItem, key.to_s)
+        self
+      end
+
+      def clear
+        @handle.call(:clear)
+        self
+      end
+
+      def length
+        @handle[:length].to_i
+      end
+
+      def key(index)
+        @handle.call(:key, index)
+      end
+    end
+
+    class Application
+      attr_reader :document, :window
+
+      def initialize(starting: nil, status_selector: "#status", status_dot_selector: "#status-dot")
+        Browser.ready!
+        @document = Browser.document
+        @window = Browser.window
+        @status = status_selector ? query(status_selector) : nil
+        @status_dot = status_dot_selector ? query(status_dot_selector) : nil
+        status(starting, state: "loading") if starting
+      end
+
+      def query(selector)
+        Element.new(@document.call(:querySelector, selector))
+      end
+
+      def element(handle)
+        Element.wrap(handle)
+      end
+
+      def status(message, state: nil)
+        setter = Browser.global[:__threeRbSetStatus]
+        if js_function?(setter)
+          Browser.global.call(:__threeRbSetStatus, message, state)
+        else
+          @status.handle[:textContent] = message if @status
+          @status_dot.handle[:dataset][:state] = state if @status_dot && state
+        end
+        self
+      end
+
+      def running!
+        status("Running", state: "running")
+      end
+
+      def boot_failed(message)
+        failure = Browser.global[:__threeRbBootFailed]
+        if js_function?(failure)
+          Browser.global.call(:__threeRbBootFailed, message)
+        else
+          status(message, state: "error")
+        end
+      end
+
+      def on_resize(viewport: "#viewport", &block)
+        raise ArgumentError, "block is required" unless block
+
+        viewport_element = viewport.is_a?(Element) ? viewport : query(viewport)
+        callback = proc do
+          width, height = viewport_element.size
+          block.call(width, height, width.to_f / height)
+        end
+
+        callback.call
+        @window.call(:addEventListener, "resize", callback)
+        callback
+      end
+
+      def on_key(name = "keydown", key: nil, target: nil, &block)
+        raise ArgumentError, "block is required" unless block
+
+        element = event_target(target || @window)
+        callback = proc do |event|
+          next if key && event[:key].to_s != key.to_s
+
+          block.call(event)
+        end
+        element.on(name, &callback)
+        callback
+      end
+
+      def on_pointer(name = "pointermove", target: "#viewport", &block)
+        raise ArgumentError, "block is required" unless block
+
+        element = event_target(target)
+        callback = proc do |event|
+          block.call(event, *element.pointer_ndc(event))
+        end
+        element.on(name, &callback)
+        callback
+      end
+
+      def pointer_ndc(event, target: "#viewport")
+        event_target(target).pointer_ndc(event)
+      end
+
+      def storage(kind = :local)
+        handle =
+          case kind
+          when :local, "local" then Browser.global[:localStorage]
+          when :session, "session" then Browser.global[:sessionStorage]
+          else kind
+          end
+
+        Storage.new(handle)
+      end
+
+      def animation_loop(renderer = nil, &block)
+        raise ArgumentError, "block is required" unless block
+
+        return renderer.animation_loop(&block) if renderer
+
+        callback = nil
+        callback = proc do |time|
+          block.call(time)
+          @window.call(:requestAnimationFrame, callback)
+        end
+        @window.call(:requestAnimationFrame, callback)
+        callback
+      end
+
+      def resize_renderer(renderer, camera, viewport: "#viewport")
+        on_resize(viewport: viewport) do |width, height, aspect|
+          if block_given?
+            yield(width, height, aspect)
+          elsif camera.respond_to?(:aspect=)
+            camera.aspect = aspect
+            camera.update_projection_matrix if camera.respond_to?(:update_projection_matrix)
+          end
+          renderer.set_size(width, height)
+        end
+      end
+
+      def expose(values, renderer: nil, prefix: "__threeRb")
+        values.each do |name, value|
+          set(name, value, renderer: renderer, prefix: prefix)
+        end
+        self
+      end
+
+      def set(name, value, renderer: nil, prefix: "__threeRb")
+        Browser.global[global_name(name, prefix)] = exposed_value(value, renderer)
+        self
+      end
+
+      def get(name, prefix: "__threeRb")
+        Browser.global[global_name(name, prefix)]
+      end
+
+      def increment(name, by: 1, prefix: "__threeRb")
+        value = get(name, prefix: prefix).to_i + by
+        set(name, value, prefix: prefix)
+        value
+      end
+
+      private
+
+      def event_target(target)
+        case target
+        when Element then target
+        when String, Symbol then query(target.to_s)
+        else Element.wrap(target)
+        end
+      end
+
+      def js_function?(value)
+        value.respond_to?(:typeof) && value.typeof == "function"
+      end
+
+      def camelize(value)
+        value.to_s.split("_").map(&:capitalize).join
+      end
+
+      def global_name(name, prefix)
+        :"#{prefix}#{camelize(name)}"
+      end
+
+      def exposed_value(value, renderer)
+        if value.is_a?(Array)
+          js_array(value, renderer)
+        elsif renderer && materializable?(value)
+          renderer.backend.materialize(value)
+        elsif value.respond_to?(:handle)
+          value.handle
+        else
+          value
+        end
+      end
+
+      def js_array(values, renderer)
+        array = Browser.global[:Array].new
+        values.each { |value| array.call(:push, exposed_value(value, renderer)) }
+        array
+      end
+
+      def materializable?(value)
+        value.respond_to?(:uuid) || value.respond_to?(:source) || value.respond_to?(:sources)
+      end
+    end
+
+    class << self
+      def run(**options)
+        app = nil
+        begin
+          install_runtime_extensions
+          app = Application.new(**options)
+          result = yield app
+          app.running!
+          result
+        rescue StandardError => error
+          app ? app.boot_failed(error.message) : notify_boot_failed(error.message)
+          raise
+        end
+      end
+
+      def ready!
+        ready = global[:__threeReady]
+        ready.await if ready.respond_to?(:await)
+        self
+      end
+
+      def document
+        global[:document]
+      end
+
+      def window
+        global[:window]
+      end
+
+      def js
+        require "js"
+        JS.global
+      rescue LoadError
+        raise Error, "Three::Browser.js requires ruby.wasm's js gem"
+      end
+
+      def global
+        js
+      end
+
+      private
+
+      def install_runtime_extensions
+        install_renderer_extensions
+        install_backend_extensions
+        install_adapter_extensions
+      end
+
+      def install_renderer_extensions
+        renderer = Three::Renderers::ThreeJSRenderer
+        unless renderer.method_defined?(:on_dispose)
+          renderer.class_eval do
+            def on_dispose(object, &block)
+              @backend.add_event_listener(object, :dispose, block)
+              self
+            end
+          end
+        end
+
+        return if renderer.method_defined?(:cached?)
+
+        renderer.class_eval do
+          def cached?(object)
+            @backend.cached?(object)
+          end
+        end
+      end
+
+      def install_backend_extensions
+        backend = Three::Backends::ThreeJS
+        unless backend.method_defined?(:add_event_listener)
+          backend.class_eval do
+            def add_event_listener(object, type, callback)
+              raise ArgumentError, "callback is required" unless callback
+
+              @adapter.add_event_listener(materialize(object), type, callback)
+            end
+          end
+        end
+
+        return if backend.method_defined?(:cached?)
+
+        backend.class_eval do
+          def cached?(object)
+            key = cache_key(object)
+            key ? @handles.key?(key) : false
+          end
+        end
+      end
+
+      def install_adapter_extensions
+        adapter = Three::Backends::ThreeJS::RubyWasmAdapter
+        return if adapter.method_defined?(:add_event_listener)
+
+        adapter.class_eval do
+          def add_event_listener(handle, type, callback)
+            handle.call(:addEventListener, type.to_s, callback)
+          end
+        end
+      end
+
+      def notify_boot_failed(message)
+        failure = global[:__threeRbBootFailed]
+        global.call(:__threeRbBootFailed, message) if failure.respond_to?(:typeof) && failure.typeof == "function"
+      rescue Error
+        nil
+      end
+    end
+  end
+end

data/lib/three/constants.rb

@@ -37,4 +37,10 @@ module Three
   PCFShadowMap = 1
   PCFSoftShadowMap = 2
   VSMShadowMap = 3
+
+  NoToneMapping = 0
+  LinearToneMapping = 1
+  ReinhardToneMapping = 2
+  CineonToneMapping = 3
+  ACESFilmicToneMapping = 4
 end

data/lib/three/core/buffer_attribute.rb

@@ -84,7 +84,11 @@ module Three
     end
 
     def clone
-      self.class.new(@array, @item_size, @normalized)
+      if instance_of?(BufferAttribute)
+        self.class.new(@array, @item_size, @normalized, component_type: @component_type)
+      else
+        self.class.new(@array, @item_size, @normalized)
+      end
     end
 
     def get_component(index, component)

data/lib/three/core/buffer_geometry.rb

@@ -99,6 +99,18 @@ module Three
       self
     end
 
+    def center
+      @centered = true
+      mark_dirty!(:geometry_operations)
+      self
+    end
+
+    alias center! center
+
+    def centered?
+      @centered == true
+    end
+
     def compute_bounding_box
       position = get_attribute(:position)
       @bounding_box = nil
@@ -153,8 +165,10 @@ module Three
         index: @index&.to_h,
         attributes: @attributes.transform_values(&:to_h),
         groups: @groups.map(&:dup),
+        draw_range: serialize_draw_range(@draw_range),
         bounding_box: serialize_bounds(@bounding_box),
-        bounding_sphere: serialize_sphere(@bounding_sphere)
+        bounding_sphere: serialize_sphere(@bounding_sphere),
+        user_data: @user_data
       }
     end
 
@@ -172,6 +186,20 @@ module Three
       { center: sphere[:center].to_a, radius: sphere[:radius] }
     end
 
+    def serialize_draw_range(draw_range)
+      {
+        start: serialize_number(draw_range[:start]),
+        count: serialize_number(draw_range[:count])
+      }
+    end
+
+    def serialize_number(value)
+      return "Infinity" if value == Float::INFINITY
+      return "-Infinity" if value == -Float::INFINITY
+
+      value
+    end
+
     def bind_attribute_change(attribute)
       return unless attribute.respond_to?(:on)
 

data/lib/three/core/object3d.rb

@@ -27,8 +27,9 @@ module Three
     attr_reader :layers
     attr_reader :position, :rotation, :quaternion, :scale
     attr_reader :matrix, :matrix_world
+    attr_reader :matrix_auto_update
     attr_reader :name, :type, :up, :visible, :cast_shadow, :receive_shadow
-    attr_accessor :matrix_auto_update, :matrix_world_auto_update, :matrix_world_needs_update
+    attr_accessor :matrix_world_auto_update, :matrix_world_needs_update
     attr_accessor :user_data
 
     def initialize
@@ -52,6 +53,7 @@ module Three
       @matrix_auto_update = DEFAULT_MATRIX_AUTO_UPDATE
       @matrix_world_auto_update = DEFAULT_MATRIX_WORLD_AUTO_UPDATE
       @matrix_world_needs_update = false
+      @suppress_matrix_change = false
       @visible = true
       @cast_shadow = false
       @receive_shadow = false
@@ -59,6 +61,7 @@ module Three
 
       bind_rotation_and_quaternion
       bind_transform_changes
+      bind_matrix_changes
       bind_layer_changes
       mark_dirty!
     end
@@ -93,6 +96,18 @@ module Three
       mark_dirty!(:properties)
     end
 
+    def matrix=(value)
+      @matrix = coerce_matrix4(value)
+      bind_matrix_changes
+      @matrix_world_needs_update = true
+      mark_dirty!(:transform)
+    end
+
+    def matrix_auto_update=(value)
+      @matrix_auto_update = value
+      mark_dirty!(:transform)
+    end
+
     def mark_dirty!(field = :all)
       super
       @parent&.mark_descendant_dirty!
@@ -188,9 +203,13 @@ module Three
     end
 
     def update_matrix
+      @suppress_matrix_change = true
       @matrix.compose(@position, @quaternion, @scale)
+      @suppress_matrix_change = false
       @matrix_world_needs_update = true
       self
+    ensure
+      @suppress_matrix_change = false
     end
 
     def update_matrix_world(force = false)
@@ -324,8 +343,27 @@ module Three
       end
     end
 
+    def bind_matrix_changes
+      @matrix.on_change do
+        next if @suppress_matrix_change
+
+        @matrix_world_needs_update = true
+        mark_dirty!(:transform)
+      end
+    end
+
     def bind_layer_changes
       @layers.on_change { mark_dirty!(:properties) }
     end
+
+    def coerce_matrix4(value)
+      return value if value.is_a?(Matrix4)
+
+      array = value.to_ary if value.respond_to?(:to_ary)
+      array ||= value.to_a if value.respond_to?(:to_a)
+      return Matrix4.new.from_array(array) if array && array.length >= 16
+
+      raise TypeError, "matrix must be a Three::Matrix4 or an array-like with 16 elements"
+    end
   end
 end

data/lib/three/exporters/three_json_exporter.rb

@@ -58,6 +58,7 @@ module Three
           user_data: object.user_data,
           children: object.children.map { |child| serialize_object(child) }
         }
+        data[:matrix] = object.matrix.to_a unless object.matrix_auto_update
 
         serialize_scene(object, data) if object.is_a?(Scene)
         serialize_camera(object, data) if object.is_a?(Camera)
@@ -71,6 +72,8 @@ module Three
       def serialize_scene(scene, data)
         data[:background] = serialize_texture_reference(scene.background)
         data[:environment] = serialize_texture_reference(scene.environment)
+        data[:fog] = scene.fog.to_h if scene.fog
+        data[:override_material] = register_material(scene.override_material) if scene.override_material
       end
 
       def serialize_camera(camera, data)