three-rb 0.1.0

data/lib/three/backends/base.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Three
+  module Backends
+    class Base
+      def materialize(_object)
+        raise NotImplementedError
+      end
+
+      def sync(_object)
+        raise NotImplementedError
+      end
+
+      def dispose(_object, **_options)
+        raise NotImplementedError
+      end
+
+      def set_renderer_shadow_map(_renderer_handle, **_options)
+        raise NotImplementedError
+      end
+
+      def traverse_handles(_object, &_block)
+        raise NotImplementedError
+      end
+
+      def dispose_subtree(_object, **_options)
+        raise NotImplementedError
+      end
+
+      def create_raycaster
+        raise NotImplementedError
+      end
+
+      def set_raycaster_from_camera(_raycaster_handle, _coords, _camera)
+        raise NotImplementedError
+      end
+
+      def intersect_objects(_raycaster_handle, _objects, recursive: false)
+        raise NotImplementedError
+      end
+
+      def create_animation_mixer(_root_handle)
+        raise NotImplementedError
+      end
+
+      def animation_mixer_clip_action(_mixer_handle, _clip_handle, _root_handle = nil)
+        raise NotImplementedError
+      end
+
+      def update_animation_mixer(_mixer_handle, _delta)
+        raise NotImplementedError
+      end
+
+      def stop_all_animation_actions(_mixer_handle)
+        raise NotImplementedError
+      end
+
+      def uncache_animation_root(_mixer_handle, _root_handle)
+        raise NotImplementedError
+      end
+
+      def set_animation_action_property(_action_handle, _name, _value)
+        raise NotImplementedError
+      end
+
+      def play_animation_action(_action_handle)
+        raise NotImplementedError
+      end
+
+      def stop_animation_action(_action_handle)
+        raise NotImplementedError
+      end
+
+      def reset_animation_action(_action_handle)
+        raise NotImplementedError
+      end
+
+      def fade_in_animation_action(_action_handle, _duration)
+        raise NotImplementedError
+      end
+
+      def fade_out_animation_action(_action_handle, _duration)
+        raise NotImplementedError
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Three
+  module Backends
+    class ThreeJS
+      module Materialization
+        private
+
+        def build_handle(object)
+          case object
+          when OrthographicCamera
+            @adapter.new_orthographic_camera(object.left, object.right, object.top, object.bottom, object.near, object.far)
+          when PerspectiveCamera
+            @adapter.new_perspective_camera(object.fov, object.aspect, object.near, object.far)
+          when Scene
+            @adapter.new_scene
+          when InstancedMesh
+            @adapter.new_instanced_mesh(materialize(object.geometry), materialize(object.material), object.count)
+          when Line
+            @adapter.new_line(materialize(object.geometry), materialize(object.material))
+          when Mesh
+            @adapter.new_mesh(materialize(object.geometry), materialize(object.material))
+          when Points
+            @adapter.new_points(materialize(object.geometry), materialize(object.material))
+          when Sprite
+            @adapter.new_sprite(materialize(object.material))
+          when CubeTexture
+            @adapter.load_cube_texture(object.sources, texture_parameters(object))
+          when RGBETexture
+            @adapter.load_rgbe_texture(object.source, texture_parameters(object))
+          when Texture
+            @adapter.load_texture(object.source, texture_parameters(object))
+          when AmbientLight
+            @adapter.new_ambient_light(object.color.hex, object.intensity)
+          when DirectionalLight
+            @adapter.new_directional_light(object.color.hex, object.intensity)
+          when PointLight
+            @adapter.new_point_light(object.color.hex, object.intensity, object.distance, object.decay)
+          when HemisphereLight
+            @adapter.new_hemisphere_light(object.color.hex, object.ground_color.hex, object.intensity)
+          when BoxGeometry
+            parameters = object.parameters
+            @adapter.new_box_geometry(
+              parameters[:width],
+              parameters[:height],
+              parameters[:depth],
+              parameters[:width_segments],
+              parameters[:height_segments],
+              parameters[:depth_segments]
+            )
+          when PlaneGeometry
+            parameters = object.parameters
+            @adapter.new_plane_geometry(
+              parameters[:width],
+              parameters[:height],
+              parameters[:width_segments],
+              parameters[:height_segments]
+            )
+          when SphereGeometry
+            parameters = object.parameters
+            @adapter.new_sphere_geometry(
+              parameters[:radius],
+              parameters[:width_segments],
+              parameters[:height_segments],
+              parameters[:phi_start],
+              parameters[:phi_length],
+              parameters[:theta_start],
+              parameters[:theta_length]
+            )
+          when BufferGeometry
+            build_buffer_geometry(object)
+          when LineBasicMaterial
+            @adapter.new_line_basic_material(material_parameters(object))
+          when MeshBasicMaterial
+            @adapter.new_mesh_basic_material(material_parameters(object))
+          when MeshLambertMaterial
+            @adapter.new_mesh_lambert_material(material_parameters(object))
+          when MeshMatcapMaterial
+            @adapter.new_mesh_matcap_material(material_parameters(object))
+          when MeshNormalMaterial
+            @adapter.new_mesh_normal_material(material_parameters(object))
+          when MeshPhongMaterial
+            @adapter.new_mesh_phong_material(material_parameters(object))
+          when MeshPhysicalMaterial
+            @adapter.new_mesh_physical_material(material_parameters(object))
+          when MeshStandardMaterial
+            @adapter.new_mesh_standard_material(material_parameters(object))
+          when MeshToonMaterial
+            @adapter.new_mesh_toon_material(material_parameters(object))
+          when PointsMaterial
+            @adapter.new_points_material(material_parameters(object))
+          when ShadowMaterial
+            @adapter.new_shadow_material(material_parameters(object))
+          when SpriteMaterial
+            @adapter.new_sprite_material(material_parameters(object))
+          when Group
+            @adapter.new_group
+          when ExternalObject3D
+            object.handle
+          when Object3D
+            @adapter.new_object3d
+          else
+            raise TypeError, "unsupported ThreeJS backend object: #{object.class}"
+          end
+        end
+
+        def build_buffer_geometry(geometry)
+          handle = @adapter.new_buffer_geometry
+
+          @adapter.set_geometry_index(handle, build_buffer_attribute(geometry.index)) if geometry.index
+          geometry.attributes.each do |name, attribute|
+            @adapter.set_geometry_attribute(handle, name, build_buffer_attribute(attribute))
+          end
+          geometry.groups.each do |group|
+            @adapter.add_geometry_group(handle, group[:start], group[:count], group[:material_index])
+          end
+          @adapter.set_geometry_draw_range(handle, geometry.draw_range[:start], geometry.draw_range[:count])
+          handle
+        end
+
+        def build_buffer_attribute(attribute)
+          @adapter.new_buffer_attribute(attribute.component_type, attribute.array, attribute.item_size, attribute.normalized)
+        end
+
+        def mark_clean_after_materialize(object)
+          case object
+          when Material
+            object.mark_clean!
+          when Texture
+            object.mark_clean!
+          when BufferGeometry
+            @geometry_attribute_names[object.uuid] = object.attributes.keys
+            object.mark_clean!
+            object.index&.mark_clean!
+            object.attributes.each_value(&:mark_clean!)
+          end
+        end
+      end
+
+      include Materialization
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Three
+  module Backends
+    class ThreeJS
+      module Parameters
+        private
+
+        def material_parameters(material)
+          parameters = {
+            opacity: material.opacity,
+            transparent: material.transparent,
+            visible: material.visible,
+            side: material.side,
+            vertexColors: material.vertex_colors
+          }
+          parameters[:color] = material.color.hex if material.respond_to?(:color)
+          parameters[:emissive] = material.emissive.hex if material.respond_to?(:emissive)
+          parameters[:specular] = material.specular.hex if material.respond_to?(:specular)
+          parameters[:shininess] = material.shininess if material.respond_to?(:shininess)
+          parameters[:roughness] = material.roughness if material.respond_to?(:roughness)
+          parameters[:metalness] = material.metalness if material.respond_to?(:metalness)
+          parameters[:anisotropy] = material.anisotropy if material.respond_to?(:anisotropy)
+          parameters[:anisotropyRotation] = material.anisotropy_rotation if material.respond_to?(:anisotropy_rotation)
+          parameters[:clearcoat] = material.clearcoat if material.respond_to?(:clearcoat)
+          parameters[:clearcoatRoughness] = material.clearcoat_roughness if material.respond_to?(:clearcoat_roughness)
+          parameters[:transmission] = material.transmission if material.respond_to?(:transmission)
+          parameters[:thickness] = material.thickness if material.respond_to?(:thickness)
+          parameters[:ior] = material.ior if material.respond_to?(:ior)
+          parameters[:reflectivity] = material.reflectivity if material.respond_to?(:reflectivity)
+          parameters[:iridescence] = material.iridescence if material.respond_to?(:iridescence)
+          parameters[:iridescenceIOR] = material.iridescence_ior if material.respond_to?(:iridescence_ior)
+          if material.respond_to?(:iridescence_thickness_range) && material.iridescence_thickness_range
+            parameters[:iridescenceThicknessRange] = material.iridescence_thickness_range.dup
+          end
+          parameters[:sheen] = material.sheen if material.respond_to?(:sheen)
+          parameters[:sheenColor] = material.sheen_color.hex if material.respond_to?(:sheen_color)
+          parameters[:sheenRoughness] = material.sheen_roughness if material.respond_to?(:sheen_roughness)
+          parameters[:dispersion] = material.dispersion if material.respond_to?(:dispersion)
+          parameters[:specularIntensity] = material.specular_intensity if material.respond_to?(:specular_intensity)
+          parameters[:specularColor] = material.specular_color.hex if material.respond_to?(:specular_color)
+          parameters[:attenuationDistance] = material.attenuation_distance if material.respond_to?(:attenuation_distance) && material.attenuation_distance
+          parameters[:attenuationColor] = material.attenuation_color.hex if material.respond_to?(:attenuation_color)
+          parameters[:linewidth] = material.linewidth if material.respond_to?(:linewidth)
+          parameters[:linecap] = material.linecap if material.respond_to?(:linecap)
+          parameters[:linejoin] = material.linejoin if material.respond_to?(:linejoin)
+          parameters[:rotation] = material.rotation if material.respond_to?(:rotation)
+          parameters[:size] = material.size if material.respond_to?(:size)
+          parameters[:sizeAttenuation] = material.size_attenuation if material.respond_to?(:size_attenuation)
+          parameters[:fog] = material.fog if material.respond_to?(:fog)
+          material_texture_parameters(material).each do |ruby_name, threejs_name|
+            texture = material.public_send(ruby_name)
+            parameters[threejs_name] = texture ? sync(texture) : nil
+          end
+          parameters[:wireframe] = material.wireframe if material.respond_to?(:wireframe)
+          parameters[:flatShading] = material.flat_shading if material.respond_to?(:flat_shading)
+          parameters
+        end
+
+        def material_texture_parameters(material)
+          MATERIAL_TEXTURE_PARAMETERS.select { |ruby_name, _threejs_name| material.respond_to?(ruby_name) }
+        end
+
+        def light_shadow_parameters(light)
+          parameters = {
+            map_size: light.shadow_map_size,
+            bias: light.shadow_bias,
+            normal_bias: light.shadow_normal_bias,
+            radius: light.shadow_radius
+          }
+          parameters[:camera] = light.shadow_camera if light.respond_to?(:shadow_camera)
+          parameters
+        end
+
+        def texture_parameters(texture)
+          {
+            mapping: texture.mapping,
+            color_space: texture.color_space,
+            flip_y: texture.flip_y,
+            wrap_s: texture.wrap_s,
+            wrap_t: texture.wrap_t,
+            mag_filter: texture.mag_filter,
+            min_filter: texture.min_filter,
+            offset: texture.offset.to_a,
+            repeat: texture.repeat.to_a,
+            center: texture.center.to_a,
+            rotation: texture.rotation,
+            matrix_auto_update: texture.matrix_auto_update,
+            matrix: texture.matrix.to_a
+          }
+        end
+      end
+
+      include Parameters
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Three
+  module Backends
+    class ThreeJS
+      module ResourceManagement
+        private
+
+        def dispose_material_textures(material)
+          material_textures(material).each { |texture| dispose(texture) }
+        end
+
+        def release_cached_subtree_handles(object, dispose_geometries:, dispose_materials:, dispose_textures:)
+          if object.respond_to?(:traverse)
+            object.traverse do |node|
+              release_cached_object_handles(
+                node,
+                dispose_geometries: dispose_geometries,
+                dispose_materials: dispose_materials,
+                dispose_textures: dispose_textures
+              )
+            end
+          else
+            key = cache_key(object)
+            @handles.delete(key) if key
+          end
+        end
+
+        def release_cached_object_handles(object, dispose_geometries:, dispose_materials:, dispose_textures:)
+          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
+
+          if object.respond_to?(:geometry) && object.respond_to?(:material)
+            release_cached_resource(object.geometry) if dispose_geometries
+          end
+
+          if object.respond_to?(:material)
+            release_cached_material(object.material, dispose_textures: dispose_textures) if dispose_materials
+          end
+
+          return unless object.is_a?(Scene) && dispose_textures
+
+          release_cached_resource(object.background)
+          release_cached_resource(object.environment)
+        end
+
+        def release_cached_material(material, dispose_textures:)
+          release_cached_resource(material)
+          material_textures(material).each { |texture| release_cached_resource(texture) } if dispose_textures
+        end
+
+        def release_cached_resource(resource)
+          key = cache_key(resource)
+          @handles.delete(key) if key
+        end
+
+        def material_textures(material)
+          return material.textures if material.respond_to?(:textures)
+
+          []
+        end
+      end
+
+      include ResourceManagement
+    end
+  end
+end