three-rb 0.1.0

data/lib/three/backends/threejs/synchronization.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module Three
+  module Backends
+    class ThreeJS
+      module Synchronization
+        private
+
+        def sync_object3d(object, handle)
+          sync_scene(object, handle) if object.is_a?(Scene) && (object.dirty_field?(:scene) || scene_resource_dirty?(object))
+
+          if object.dirty_field?(:properties)
+            @adapter.set_object_name(handle, object.name)
+            @adapter.set_object_visible(handle, object.visible)
+            @adapter.set_object_shadow(handle, object.cast_shadow, object.receive_shadow)
+            @adapter.set_object_layers(handle, object.layers.mask)
+          end
+
+          if object.dirty_field?(:transform)
+            @adapter.set_object_transform(handle, object.position.to_a, object.quaternion.to_a, object.scale.to_a)
+          end
+
+          if object.dirty_field?(:camera)
+            sync_camera(object, handle)
+          end
+
+          sync_light(object, handle) if object.is_a?(Light) && object.dirty_field?(:light)
+
+          if object.is_a?(InstancedMesh)
+            sync_instanced_mesh(object, handle)
+          elsif object.is_a?(Sprite)
+            sync_sprite(object, handle)
+          elsif geometry_material_object?(object)
+            sync_geometry_material_object(object, handle)
+          end
+
+          if object.dirty_field?(:children)
+            @adapter.clear_children(handle)
+            object.children.each do |child|
+              child_handle = sync(child)
+              @adapter.add_child(handle, child_handle)
+            end
+          elsif object.dirty_field?(:descendants)
+            object.children.each { |child| sync(child) if child.dirty? }
+          else
+            # Clean subtrees do not need a Ruby-to-JavaScript sync pass.
+          end
+
+          object.mark_clean! if object.respond_to?(:mark_clean!)
+          handle
+        end
+
+        def sync_instanced_mesh(object, handle)
+          geometry_handle = sync(object.geometry)
+          material_handle = sync(object.material) if object.material.respond_to?(:uuid)
+
+          if object.dirty_field?(:mesh)
+            @adapter.set_object_geometry(handle, geometry_handle)
+            @adapter.set_object_material(handle, material_handle) if material_handle
+            @adapter.set_instanced_mesh_count(handle, object.count)
+          end
+
+          if object.dirty_field?(:instances)
+            object.instance_matrices.each_with_index do |matrix, index|
+              @adapter.set_instanced_mesh_matrix_at(handle, index, matrix.to_a)
+            end
+            @adapter.set_instanced_mesh_instance_matrix_needs_update(handle, true)
+          end
+
+          sync_instanced_mesh_colors(object, handle) if object.dirty_field?(:instance_colors)
+        end
+
+        def geometry_material_object?(object)
+          object.is_a?(Mesh) || object.is_a?(Line) || object.is_a?(Points)
+        end
+
+        def sync_sprite(object, handle)
+          material_handle = sync(object.material) if object.material.respond_to?(:uuid)
+
+          if object.dirty_field?(:sprite)
+            @adapter.set_object_material(handle, material_handle) if material_handle
+            @adapter.set_sprite_center(handle, object.center.to_a)
+          end
+        end
+
+        def sync_geometry_material_object(object, handle)
+          geometry_handle = sync(object.geometry)
+          material_handle = sync(object.material) if object.material.respond_to?(:uuid)
+          dirty_field = geometry_material_dirty_field(object)
+
+          if object.dirty_field?(dirty_field)
+            @adapter.set_object_geometry(handle, geometry_handle)
+            @adapter.set_object_material(handle, material_handle) if material_handle
+          end
+        end
+
+        def geometry_material_dirty_field(object)
+          case object
+          when Line
+            :line
+          when Points
+            :points
+          else
+            :mesh
+          end
+        end
+
+        def sync_instanced_mesh_colors(object, handle)
+          return unless object.instance_colors
+
+          object.instance_colors.each_with_index do |color, index|
+            @adapter.set_instanced_mesh_color_at(handle, index, color.to_a)
+          end
+          @adapter.set_instanced_mesh_instance_color_needs_update(handle, true)
+        end
+
+        def sync_scene(scene, handle)
+          @adapter.set_scene_background(handle, scene.background ? sync(scene.background) : nil)
+          @adapter.set_scene_environment(handle, scene.environment ? sync(scene.environment) : nil)
+        end
+
+        def scene_resource_dirty?(scene)
+          [scene.background, scene.environment].compact.any? do |resource|
+            resource.respond_to?(:dirty?) && resource.dirty?
+          end
+        end
+
+        def sync_camera(object, handle)
+          case object
+          when OrthographicCamera
+            @adapter.update_orthographic_camera(handle, object.left, object.right, object.top, object.bottom, object.near, object.far, object.zoom)
+          when PerspectiveCamera
+            @adapter.update_perspective_camera(handle, object.fov, object.aspect, object.near, object.far, object.zoom)
+          end
+        end
+
+        def sync_light(object, handle)
+          case object
+          when PointLight
+            @adapter.update_point_light(handle, object.color.hex, object.intensity, object.distance, object.decay)
+          when HemisphereLight
+            @adapter.update_hemisphere_light(handle, object.color.hex, object.ground_color.hex, object.intensity)
+          else
+            @adapter.update_light(handle, object.color.hex, object.intensity)
+          end
+          @adapter.update_light_shadow(handle, light_shadow_parameters(object)) if shadow_dirty?(object)
+        end
+
+        def shadow_dirty?(object)
+          object.dirty_fields.key?(:all) || object.dirty_field?(:shadow)
+        end
+
+        def sync_material(material, handle)
+          sync_material_textures(material)
+          return handle unless material.dirty?
+
+          @adapter.update_material(handle, material_parameters(material))
+          material.mark_clean!
+          handle
+        end
+
+        def sync_material_textures(material)
+          material_textures(material).each { |texture| sync(texture) }
+        end
+
+        def sync_texture(texture, handle)
+          return handle unless texture.dirty?
+
+          @adapter.update_texture(handle, texture_parameters(texture))
+          texture.mark_clean!
+          handle
+        end
+
+        def sync_geometry(geometry, handle)
+          return handle if built_in_geometry?(geometry)
+          return handle unless geometry_dirty?(geometry)
+
+          if geometry.dirty_field?(:all) || geometry.dirty_field?(:index) || geometry.index&.dirty?
+            @adapter.set_geometry_index(handle, geometry.index ? build_buffer_attribute(geometry.index) : nil)
+            geometry.index&.mark_clean!
+          end
+
+          if geometry.dirty_field?(:all) || geometry.dirty_field?(:attributes) || geometry.attributes.values.any?(&:dirty?)
+            previous_names = @geometry_attribute_names[geometry.uuid] || []
+            current_names = geometry.attributes.keys
+            (previous_names - current_names).each { |name| @adapter.delete_geometry_attribute(handle, name) }
+
+            geometry.attributes.each do |name, attribute|
+              @adapter.set_geometry_attribute(handle, name, build_buffer_attribute(attribute))
+              attribute.mark_clean!
+            end
+            @geometry_attribute_names[geometry.uuid] = current_names
+          end
+
+          if geometry.dirty_field?(:all) || geometry.dirty_field?(:groups)
+            @adapter.clear_geometry_groups(handle)
+            geometry.groups.each do |group|
+              @adapter.add_geometry_group(handle, group[:start], group[:count], group[:material_index])
+            end
+          end
+
+          if geometry.dirty_field?(:all) || geometry.dirty_field?(:draw_range)
+            @adapter.set_geometry_draw_range(handle, geometry.draw_range[:start], geometry.draw_range[:count])
+          end
+
+          geometry.mark_clean!
+          handle
+        end
+
+        def geometry_dirty?(geometry)
+          geometry.dirty? ||
+            geometry.index&.dirty? ||
+            geometry.attributes.values.any?(&:dirty?)
+        end
+
+        def built_in_geometry?(geometry)
+          geometry.is_a?(BoxGeometry) || geometry.is_a?(PlaneGeometry) || geometry.is_a?(SphereGeometry)
+        end
+      end
+
+      include Synchronization
+    end
+  end
+end

data/lib/three/backends/threejs.rb

@@ -0,0 +1,365 @@
+# frozen_string_literal: true
+
+require_relative "../cameras/orthographic_camera"
+require_relative "../cameras/perspective_camera"
+require_relative "../core/buffer_geometry"
+require_relative "../geometries/box_geometry"
+require_relative "../geometries/plane_geometry"
+require_relative "../geometries/sphere_geometry"
+require_relative "../lights/ambient_light"
+require_relative "../lights/directional_light"
+require_relative "../lights/hemisphere_light"
+require_relative "../lights/point_light"
+require_relative "../materials/line_basic_material"
+require_relative "../materials/mesh_basic_material"
+require_relative "../materials/mesh_lambert_material"
+require_relative "../materials/mesh_matcap_material"
+require_relative "../materials/mesh_normal_material"
+require_relative "../materials/mesh_phong_material"
+require_relative "../materials/mesh_standard_material"
+require_relative "../materials/mesh_physical_material"
+require_relative "../materials/mesh_toon_material"
+require_relative "../materials/points_material"
+require_relative "../materials/shadow_material"
+require_relative "../materials/sprite_material"
+require_relative "../objects/external_object3d"
+require_relative "../objects/instanced_mesh"
+require_relative "../objects/line"
+require_relative "../objects/mesh"
+require_relative "../objects/points"
+require_relative "../objects/sprite"
+require_relative "../scenes/scene"
+require_relative "../textures/cube_texture"
+require_relative "../textures/rgbe_texture"
+require_relative "../textures/texture"
+require_relative "base"
+
+module Three
+  module Backends
+    class ThreeJS < Base
+      MATERIAL_TEXTURE_PARAMETERS = {
+        map: :map,
+        alpha_map: :alphaMap,
+        ao_map: :aoMap,
+        bump_map: :bumpMap,
+        displacement_map: :displacementMap,
+        emissive_map: :emissiveMap,
+        env_map: :envMap,
+        gradient_map: :gradientMap,
+        light_map: :lightMap,
+        matcap: :matcap,
+        metalness_map: :metalnessMap,
+        normal_map: :normalMap,
+        roughness_map: :roughnessMap,
+        specular_map: :specularMap,
+        anisotropy_map: :anisotropyMap,
+        clearcoat_map: :clearcoatMap,
+        clearcoat_normal_map: :clearcoatNormalMap,
+        clearcoat_roughness_map: :clearcoatRoughnessMap,
+        transmission_map: :transmissionMap,
+        thickness_map: :thicknessMap,
+        iridescence_map: :iridescenceMap,
+        iridescence_thickness_map: :iridescenceThicknessMap,
+        sheen_color_map: :sheenColorMap,
+        sheen_roughness_map: :sheenRoughnessMap,
+        specular_color_map: :specularColorMap,
+        specular_intensity_map: :specularIntensityMap
+      }.freeze
+
+      MATERIAL_COLOR_PARAMETERS = %i[color emissive specular attenuationColor sheenColor specularColor].freeze
+
+      attr_reader :adapter, :handles
+
+      def initialize(adapter: nil)
+        @adapter = adapter || RubyWasmAdapter.new
+        @handles = {}
+        @objects_by_handle_key = {}
+        @geometry_attribute_names = {}
+      end
+
+      def create_renderer(canvas: nil, **options)
+        @adapter.new_webgl_renderer({ canvas: canvas }.merge(options))
+      end
+
+      def renderer_dom_element(renderer_handle)
+        @adapter.renderer_dom_element(renderer_handle)
+      end
+
+      def set_renderer_size(renderer_handle, width, height)
+        @adapter.set_renderer_size(renderer_handle, width, height)
+      end
+
+      def set_clear_color(renderer_handle, color, alpha = 1)
+        @adapter.set_clear_color(renderer_handle, color, alpha)
+      end
+
+      def set_renderer_shadow_map(renderer_handle, enabled: nil, type: nil, auto_update: nil)
+        @adapter.set_renderer_shadow_map(renderer_handle, enabled: enabled, type: type, auto_update: auto_update)
+      end
+
+      def set_animation_loop(renderer_handle, callback)
+        @adapter.set_animation_loop(renderer_handle, callback)
+      end
+
+      def render(renderer_handle, scene, camera)
+        scene_handle = sync(scene)
+        camera_handle = sync(camera)
+        @adapter.render(renderer_handle, scene_handle, camera_handle)
+      end
+
+      def create_effect_composer(renderer_handle)
+        @adapter.new_effect_composer(renderer_handle)
+      end
+
+      def add_effect_composer_pass(composer_handle, pass_handle)
+        @adapter.effect_composer_add_pass(composer_handle, pass_handle)
+      end
+
+      def set_effect_composer_size(composer_handle, width, height)
+        @adapter.effect_composer_set_size(composer_handle, width, height)
+      end
+
+      def render_effect_composer(composer_handle, scene = nil, camera = nil)
+        sync(scene) if scene
+        sync(camera) if camera
+        @adapter.effect_composer_render(composer_handle)
+      end
+
+      def dispose_effect_composer(composer_handle)
+        @adapter.dispose_effect_composer(composer_handle)
+      end
+
+      def create_render_pass(scene, camera)
+        @adapter.new_render_pass(sync(scene), sync(camera))
+      end
+
+      def create_unreal_bloom_pass(resolution, strength, radius, threshold)
+        @adapter.new_unreal_bloom_pass(resolution, strength, radius, threshold)
+      end
+
+      def create_dot_screen_pass(center, angle, scale)
+        @adapter.new_dot_screen_pass(center, angle, scale)
+      end
+
+      def create_output_pass
+        @adapter.new_output_pass
+      end
+
+      def set_postprocessing_pass_property(pass_handle, name, value)
+        @adapter.set_postprocessing_pass_property(pass_handle, name, value)
+      end
+
+      def set_postprocessing_pass_uniform(pass_handle, name, value)
+        @adapter.set_postprocessing_pass_uniform(pass_handle, name, value)
+      end
+
+      def create_orbit_controls(camera, dom_element = nil)
+        @adapter.new_orbit_controls(camera, dom_element)
+      end
+
+      def set_control_property(control_handle, name, value)
+        @adapter.set_control_property(control_handle, name, value)
+      end
+
+      def set_orbit_controls_target(control_handle, target)
+        @adapter.set_orbit_controls_target(control_handle, target)
+      end
+
+      def update_controls(control_handle)
+        @adapter.update_controls(control_handle)
+      end
+
+      def dispose_controls(control_handle)
+        @adapter.dispose_controls(control_handle)
+      end
+
+      def sync_object_transform_from_handle(object)
+        handle = materialize(object)
+        position, quaternion, scale = @adapter.object_transform(handle)
+        object.position.set(*position)
+        object.quaternion.set(*quaternion)
+        object.scale.set(*scale)
+        object.mark_clean!(:transform) if object.respond_to?(:mark_clean!)
+        object
+      end
+
+      def create_raycaster
+        @adapter.new_raycaster
+      end
+
+      def set_raycaster_from_camera(raycaster_handle, coords, camera)
+        @adapter.set_raycaster_from_camera(raycaster_handle, coords, sync(camera))
+      end
+
+      def intersect_objects(raycaster_handle, objects, recursive: false)
+        handles = Array(objects).map { |object| sync(object) }
+        @adapter.intersect_objects(raycaster_handle, handles, recursive: recursive).map do |intersection|
+          normalize_intersection(intersection)
+        end
+      end
+
+      def create_animation_mixer(root_handle)
+        @adapter.new_animation_mixer(root_handle)
+      end
+
+      def animation_mixer_clip_action(mixer_handle, clip_handle, root_handle = nil)
+        @adapter.animation_mixer_clip_action(mixer_handle, clip_handle, root_handle)
+      end
+
+      def update_animation_mixer(mixer_handle, delta)
+        @adapter.update_animation_mixer(mixer_handle, delta)
+      end
+
+      def stop_all_animation_actions(mixer_handle)
+        @adapter.stop_all_animation_actions(mixer_handle)
+      end
+
+      def uncache_animation_root(mixer_handle, root_handle)
+        @adapter.uncache_animation_root(mixer_handle, root_handle)
+      end
+
+      def set_animation_action_property(action_handle, name, value)
+        @adapter.set_animation_action_property(action_handle, name, value)
+      end
+
+      def play_animation_action(action_handle)
+        @adapter.play_animation_action(action_handle)
+      end
+
+      def stop_animation_action(action_handle)
+        @adapter.stop_animation_action(action_handle)
+      end
+
+      def reset_animation_action(action_handle)
+        @adapter.reset_animation_action(action_handle)
+      end
+
+      def fade_in_animation_action(action_handle, duration)
+        @adapter.fade_in_animation_action(action_handle, duration)
+      end
+
+      def fade_out_animation_action(action_handle, duration)
+        @adapter.fade_out_animation_action(action_handle, duration)
+      end
+
+      def materialize(object)
+        key = cache_key(object)
+        return @handles[key] if key && @handles.key?(key)
+
+        handle = build_handle(object)
+        @handles[key] = handle if key
+        register_object_handle(object, handle)
+        mark_clean_after_materialize(object)
+        handle
+      end
+
+      def sync(object)
+        handle = materialize(object)
+
+        case object
+        when Object3D
+          sync_object3d(object, handle)
+        when BufferGeometry
+          sync_geometry(object, handle)
+        when Texture
+          sync_texture(object, handle)
+        when Material
+          sync_material(object, handle)
+        end
+
+        handle
+      end
+
+      def dispose(object, dispose_textures: false)
+        dispose_material_textures(object) if dispose_textures && object.is_a?(Material)
+
+        key = cache_key(object)
+        handle = key ? @handles.delete(key) : nil
+        handle_key = @adapter.object_handle_key(handle) if handle
+        @objects_by_handle_key.delete(handle_key) if handle_key
+        @adapter.dispose(handle) if handle
+        handle
+      end
+
+      def traverse_handles(object, &block)
+        return enum_for(:traverse_handles, object) unless block
+
+        handle = object3d_handle(object)
+        @adapter.traverse_object3d(handle, block)
+        handle
+      end
+
+      def dispose_subtree(
+        object,
+        remove: true,
+        dispose_geometries: true,
+        dispose_materials: true,
+        dispose_textures: false,
+        dispose_skeletons: true
+      )
+        handle = object3d_handle(object)
+        @adapter.dispose_object3d_subtree(
+          handle,
+          remove: remove,
+          dispose_geometries: dispose_geometries,
+          dispose_materials: dispose_materials,
+          dispose_textures: dispose_textures,
+          dispose_skeletons: dispose_skeletons
+        )
+        object.remove_from_parent if remove && object.respond_to?(:remove_from_parent)
+        release_cached_subtree_handles(
+          object,
+          dispose_geometries: dispose_geometries,
+          dispose_materials: dispose_materials,
+          dispose_textures: dispose_textures
+        )
+        handle
+      end
+
+      private
+
+      def object3d_handle(object)
+        raise TypeError, "object must be a Three::Object3D" unless object.is_a?(Object3D)
+
+        sync(object)
+      end
+
+      def cache_key(object)
+        object.respond_to?(:uuid) ? object.uuid : nil
+      end
+
+      def register_object_handle(object, handle)
+        return unless object.is_a?(Object3D)
+
+        handle_key = @adapter.object_handle_key(handle)
+        @objects_by_handle_key[handle_key] = object if handle_key
+      end
+
+      def object_for_handle(handle)
+        handle_key = @adapter.object_handle_key(handle)
+        handle_key ? @objects_by_handle_key[handle_key] : nil
+      end
+
+      def normalize_intersection(intersection)
+        object_handle = @adapter.intersection_object(intersection)
+        {
+          distance: @adapter.intersection_distance(intersection),
+          point: @adapter.intersection_point(intersection),
+          object: object_for_handle(object_handle),
+          object_handle: object_handle,
+          uv: @adapter.intersection_uv(intersection),
+          face_index: @adapter.intersection_face_index(intersection),
+          index: @adapter.intersection_index(intersection),
+          instance_id: @adapter.intersection_instance_id(intersection),
+          raw: intersection
+        }
+      end
+    end
+  end
+end
+
+require_relative "threejs/parameters"
+require_relative "threejs/materialization"
+require_relative "threejs/synchronization"
+require_relative "threejs/resource_management"
+require_relative "threejs/ruby_wasm_adapter"

data/lib/three/cameras/camera.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../core/object3d"
+
+module Three
+  class Camera < Object3D
+    attr_reader :matrix_world_inverse, :projection_matrix, :projection_matrix_inverse
+
+    def initialize
+      super
+      @type = "Camera"
+      @matrix_world_inverse = Matrix4.new
+      @projection_matrix = Matrix4.new
+      @projection_matrix_inverse = Matrix4.new
+    end
+
+    def update_matrix_world(force = false)
+      super
+      update_matrix_world_inverse
+      self
+    end
+
+    def update_world_matrix(update_parents = false, update_children = false)
+      super
+      update_matrix_world_inverse
+      self
+    end
+
+    def get_world_direction(target = Vector3.new)
+      super(target).negate
+    end
+
+    private
+
+    def update_matrix_world_inverse
+      @matrix_world_inverse.copy(@matrix_world).invert
+    end
+  end
+end