three-rb 0.1.0

data/lib/three/materials/material.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require_relative "../constants"
+require_relative "../core/event_dispatcher"
+require_relative "../dirty"
+require_relative "../math/math_utils"
+
+module Three
+  class Material < EventDispatcher
+    include Dirty
+
+    @next_id = 0
+
+    class << self
+      attr_accessor :next_id
+    end
+
+    attr_reader :id, :uuid
+    attr_reader :name, :type, :side, :opacity, :transparent, :visible, :blending, :vertex_colors
+    attr_accessor :user_data
+
+    def initialize(parameters = nil)
+      super()
+      @id = self.class.allocate_id
+      @uuid = MathUtils.generate_uuid
+      @name = ""
+      @type = "Material"
+      @blending = NormalBlending
+      @side = FrontSide
+      @vertex_colors = false
+      @opacity = 1
+      @transparent = false
+      @visible = true
+      @user_data = {}
+      @needs_update = false
+      set_values(parameters) if parameters
+      mark_dirty!
+    end
+
+    def name=(value)
+      @name = value
+      mark_dirty!(:parameters)
+    end
+
+    def type=(value)
+      @type = value
+      mark_dirty!(:parameters)
+    end
+
+    def blending=(value)
+      @blending = value
+      mark_dirty!(:parameters)
+    end
+
+    def side=(value)
+      @side = value
+      mark_dirty!(:parameters)
+    end
+
+    def vertex_colors=(value)
+      @vertex_colors = value
+      mark_dirty!(:parameters)
+    end
+
+    def opacity=(value)
+      @opacity = value
+      mark_dirty!(:parameters)
+    end
+
+    def transparent=(value)
+      @transparent = value
+      mark_dirty!(:parameters)
+    end
+
+    def visible=(value)
+      @visible = value
+      mark_dirty!(:parameters)
+    end
+
+    def needs_update
+      @needs_update
+    end
+
+    def needs_update=(value)
+      @needs_update = value
+      mark_dirty!(:parameters) if value
+    end
+
+    def needs_update!
+      self.needs_update = true
+      self
+    end
+
+    def self.allocate_id
+      id = Material.next_id
+      Material.next_id += 1
+      id
+    end
+
+    def set_values(values)
+      values.each do |key, value|
+        setter = "#{key}="
+        next unless respond_to?(setter)
+
+        current_value = public_send(key) if respond_to?(key)
+        if current_value.respond_to?(:set)
+          current_value.set(value)
+        else
+          public_send(setter, value)
+        end
+      end
+      self
+    end
+
+    def dispose
+      dispatch_event(:dispose)
+    end
+
+    def dirty_dependency_changed(_resource, _field)
+      mark_dirty!(:textures)
+    end
+
+    def texture_slots
+      respond_to?(:map) ? [:map] : []
+    end
+
+    def textures
+      texture_slots.each_with_object([]) do |slot, result|
+        texture = public_send(slot)
+        result << texture if texture && !result.include?(texture)
+      end
+    end
+
+    def to_h
+      {
+        uuid: @uuid,
+        type: @type,
+        name: @name,
+        side: @side,
+        opacity: @opacity,
+        transparent: @transparent,
+        visible: @visible,
+        vertex_colors: @vertex_colors
+      }
+    end
+
+    private
+
+    def replace_texture_slot(slot, value)
+      current = instance_variable_get(:"@#{slot}")
+      current.remove_dirty_dependent(self) if current.respond_to?(:remove_dirty_dependent)
+
+      instance_variable_set(:"@#{slot}", value)
+      value.add_dirty_dependent(self) if value.respond_to?(:add_dirty_dependent)
+      mark_dirty!(:parameters)
+    end
+  end
+end

data/lib/three/materials/mesh_basic_material.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "../math/color"
+require_relative "material"
+
+module Three
+  class MeshBasicMaterial < Material
+    attr_reader :color, :wireframe, :wireframe_linewidth, :fog, :map
+
+    def initialize(parameters = nil)
+      super(nil)
+      @type = "MeshBasicMaterial"
+      @color = Color.new(0xffffff)
+      @map = nil
+      @wireframe = false
+      @wireframe_linewidth = 1
+      @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 map=(value)
+      replace_texture_slot(:map, value)
+    end
+
+    def wireframe=(value)
+      @wireframe = value
+      mark_dirty!(:parameters)
+    end
+
+    def wireframe_linewidth=(value)
+      @wireframe_linewidth = value
+      mark_dirty!(:parameters)
+    end
+
+    def fog=(value)
+      @fog = value
+      mark_dirty!(:parameters)
+    end
+
+    def to_h
+      super.merge(
+        color: @color.hex,
+        map: @map&.to_h,
+        wireframe: @wireframe,
+        wireframe_linewidth: @wireframe_linewidth,
+        fog: @fog
+      )
+    end
+
+    private
+
+    def bind_color_changes
+      @color.on_change { mark_dirty!(:parameters) }
+    end
+  end
+end

data/lib/three/materials/mesh_lambert_material.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "../math/color"
+require_relative "material"
+
+module Three
+  class MeshLambertMaterial < Material
+    attr_reader :color, :wireframe, :wireframe_linewidth, :fog, :flat_shading, :map
+
+    def initialize(parameters = nil)
+      super(nil)
+      @type = "MeshLambertMaterial"
+      @color = Color.new(0xffffff)
+      @map = nil
+      @wireframe = false
+      @wireframe_linewidth = 1
+      @fog = true
+      @flat_shading = false
+      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 map=(value)
+      replace_texture_slot(:map, value)
+    end
+
+    def wireframe=(value)
+      @wireframe = value
+      mark_dirty!(:parameters)
+    end
+
+    def wireframe_linewidth=(value)
+      @wireframe_linewidth = value
+      mark_dirty!(:parameters)
+    end
+
+    def fog=(value)
+      @fog = value
+      mark_dirty!(:parameters)
+    end
+
+    def flat_shading=(value)
+      @flat_shading = value
+      mark_dirty!(:parameters)
+    end
+
+    def to_h
+      super.merge(
+        color: @color.hex,
+        map: @map&.to_h,
+        wireframe: @wireframe,
+        wireframe_linewidth: @wireframe_linewidth,
+        fog: @fog,
+        flat_shading: @flat_shading
+      )
+    end
+
+    private
+
+    def bind_color_changes
+      @color.on_change { mark_dirty!(:parameters) }
+    end
+  end
+end

data/lib/three/materials/mesh_matcap_material.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "../math/color"
+require_relative "material"
+
+module Three
+  class MeshMatcapMaterial < Material
+    TEXTURE_SLOTS = %i[
+      matcap
+      map
+      alpha_map
+      bump_map
+      displacement_map
+      normal_map
+    ].freeze
+
+    attr_reader :color, :wireframe, :wireframe_linewidth, :fog, :flat_shading
+    attr_reader(*TEXTURE_SLOTS)
+
+    def initialize(parameters = nil)
+      super(nil)
+      @type = "MeshMatcapMaterial"
+      @color = Color.new(0xffffff)
+      TEXTURE_SLOTS.each { |slot| instance_variable_set(:"@#{slot}", nil) }
+      @wireframe = false
+      @wireframe_linewidth = 1
+      @fog = true
+      @flat_shading = false
+      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
+
+    TEXTURE_SLOTS.each do |slot|
+      define_method(:"#{slot}=") { |value| replace_texture_slot(slot, value) }
+    end
+
+    def wireframe=(value)
+      @wireframe = value
+      mark_dirty!(:parameters)
+    end
+
+    def wireframe_linewidth=(value)
+      @wireframe_linewidth = value
+      mark_dirty!(:parameters)
+    end
+
+    def fog=(value)
+      @fog = value
+      mark_dirty!(:parameters)
+    end
+
+    def flat_shading=(value)
+      @flat_shading = value
+      mark_dirty!(:parameters)
+    end
+
+    def texture_slots
+      TEXTURE_SLOTS
+    end
+
+    def to_h
+      result = super.merge(
+        color: @color.hex,
+        wireframe: @wireframe,
+        wireframe_linewidth: @wireframe_linewidth,
+        fog: @fog,
+        flat_shading: @flat_shading
+      )
+      TEXTURE_SLOTS.each { |slot| result[slot] = public_send(slot)&.to_h }
+      result
+    end
+
+    private
+
+    def bind_color_changes
+      @color.on_change { mark_dirty!(:parameters) }
+    end
+  end
+end

data/lib/three/materials/mesh_normal_material.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "material"
+
+module Three
+  class MeshNormalMaterial < Material
+    attr_reader :wireframe, :wireframe_linewidth, :flat_shading
+
+    def initialize(parameters = nil)
+      super(nil)
+      @type = "MeshNormalMaterial"
+      @wireframe = false
+      @wireframe_linewidth = 1
+      @flat_shading = false
+      set_values(parameters) if parameters
+      mark_dirty!
+    end
+
+    def wireframe=(value)
+      @wireframe = value
+      mark_dirty!(:parameters)
+    end
+
+    def wireframe_linewidth=(value)
+      @wireframe_linewidth = value
+      mark_dirty!(:parameters)
+    end
+
+    def flat_shading=(value)
+      @flat_shading = value
+      mark_dirty!(:parameters)
+    end
+
+    def to_h
+      super.merge(
+        wireframe: @wireframe,
+        wireframe_linewidth: @wireframe_linewidth,
+        flat_shading: @flat_shading
+      )
+    end
+  end
+end

data/lib/three/materials/mesh_phong_material.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_relative "../math/color"
+require_relative "material"
+
+module Three
+  class MeshPhongMaterial < Material
+    TEXTURE_SLOTS = %i[
+      map
+      alpha_map
+      ao_map
+      bump_map
+      displacement_map
+      emissive_map
+      env_map
+      light_map
+      normal_map
+      specular_map
+    ].freeze
+
+    attr_reader :color, :specular, :emissive, :shininess, :wireframe, :wireframe_linewidth, :fog, :flat_shading
+    attr_reader(*TEXTURE_SLOTS)
+
+    def initialize(parameters = nil)
+      super(nil)
+      @type = "MeshPhongMaterial"
+      @color = Color.new(0xffffff)
+      @specular = Color.new(0x111111)
+      @emissive = Color.new(0x000000)
+      @shininess = 30
+      TEXTURE_SLOTS.each { |slot| instance_variable_set(:"@#{slot}", nil) }
+      @wireframe = false
+      @wireframe_linewidth = 1
+      @fog = true
+      @flat_shading = false
+      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 specular=(value)
+      @specular = value.is_a?(Color) ? value : Color.new(value)
+      bind_color_changes
+      mark_dirty!(:parameters)
+    end
+
+    def emissive=(value)
+      @emissive = value.is_a?(Color) ? value : Color.new(value)
+      bind_color_changes
+      mark_dirty!(:parameters)
+    end
+
+    def shininess=(value)
+      @shininess = value
+      mark_dirty!(:parameters)
+    end
+
+    TEXTURE_SLOTS.each do |slot|
+      define_method(:"#{slot}=") { |value| set_texture_slot(slot, value) }
+    end
+
+    def wireframe=(value)
+      @wireframe = value
+      mark_dirty!(:parameters)
+    end
+
+    def wireframe_linewidth=(value)
+      @wireframe_linewidth = value
+      mark_dirty!(:parameters)
+    end
+
+    def fog=(value)
+      @fog = value
+      mark_dirty!(:parameters)
+    end
+
+    def flat_shading=(value)
+      @flat_shading = value
+      mark_dirty!(:parameters)
+    end
+
+    def texture_slots
+      TEXTURE_SLOTS
+    end
+
+    def to_h
+      result = super.merge(
+        color: @color.hex,
+        specular: @specular.hex,
+        emissive: @emissive.hex,
+        shininess: @shininess,
+        wireframe: @wireframe,
+        wireframe_linewidth: @wireframe_linewidth,
+        fog: @fog,
+        flat_shading: @flat_shading
+      )
+      TEXTURE_SLOTS.each { |slot| result[slot] = public_send(slot)&.to_h }
+      result
+    end
+
+    private
+
+    def bind_color_changes
+      @color.on_change { mark_dirty!(:parameters) }
+      @specular.on_change { mark_dirty!(:parameters) }
+      @emissive.on_change { mark_dirty!(:parameters) }
+    end
+
+    def set_texture_slot(slot, value)
+      replace_texture_slot(slot, value)
+    end
+  end
+end

data/lib/three/materials/mesh_physical_material.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require_relative "../math/color"
+require_relative "mesh_standard_material"
+
+module Three
+  class MeshPhysicalMaterial < MeshStandardMaterial
+    PHYSICAL_TEXTURE_SLOTS = %i[
+      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
+    ].freeze
+
+    TEXTURE_SLOTS = (MeshStandardMaterial::TEXTURE_SLOTS + PHYSICAL_TEXTURE_SLOTS).freeze
+
+    attr_reader :anisotropy, :anisotropy_rotation, :clearcoat, :clearcoat_roughness, :transmission, :thickness, :ior
+    attr_reader :iridescence, :iridescence_ior, :iridescence_thickness_range, :sheen, :sheen_color, :sheen_roughness
+    attr_reader :dispersion, :specular_intensity, :specular_color, :attenuation_distance, :attenuation_color
+    attr_reader(*PHYSICAL_TEXTURE_SLOTS)
+
+    def initialize(parameters = nil)
+      super(nil)
+      @type = "MeshPhysicalMaterial"
+      @anisotropy = 0
+      @anisotropy_rotation = 0
+      @clearcoat = 0
+      @clearcoat_roughness = 0
+      @transmission = 0
+      @thickness = 0
+      @ior = 1.5
+      @iridescence = 0
+      @iridescence_ior = 1.3
+      @iridescence_thickness_range = [100, 400]
+      @sheen = 0
+      @sheen_color = Color.new(0x000000)
+      @sheen_roughness = 1
+      @dispersion = 0
+      @specular_intensity = 1
+      @specular_color = Color.new(0xffffff)
+      @attenuation_distance = nil
+      @attenuation_color = Color.new(0xffffff)
+      PHYSICAL_TEXTURE_SLOTS.each { |slot| instance_variable_set(:"@#{slot}", nil) }
+      bind_physical_color_changes
+      set_values(parameters) if parameters
+      mark_dirty!
+    end
+
+    %i[
+      anisotropy
+      anisotropy_rotation
+      clearcoat
+      clearcoat_roughness
+      transmission
+      thickness
+      ior
+      iridescence
+      iridescence_ior
+      sheen
+      sheen_roughness
+      dispersion
+      specular_intensity
+      attenuation_distance
+    ].each do |name|
+      define_method("#{name}=") do |value|
+        instance_variable_set(:"@#{name}", value)
+        mark_dirty!(:parameters)
+      end
+    end
+
+    def iridescence_thickness_range=(value)
+      @iridescence_thickness_range = value&.dup
+      mark_dirty!(:parameters)
+    end
+
+    def reflectivity
+      MathUtils.clamp(2.5 * (@ior - 1) / (@ior + 1), 0, 1)
+    end
+
+    def reflectivity=(value)
+      return if value.nil?
+
+      @ior = (1 + 0.4 * value) / (1 - 0.4 * value)
+      mark_dirty!(:parameters)
+    end
+
+    def sheen_color=(value)
+      @sheen_color = value.is_a?(Color) ? value : Color.new(value)
+      bind_physical_color_changes
+      mark_dirty!(:parameters)
+    end
+
+    def specular_color=(value)
+      @specular_color = value.is_a?(Color) ? value : Color.new(value)
+      bind_physical_color_changes
+      mark_dirty!(:parameters)
+    end
+
+    def attenuation_color=(value)
+      @attenuation_color = value.is_a?(Color) ? value : Color.new(value)
+      bind_physical_color_changes
+      mark_dirty!(:parameters)
+    end
+
+    PHYSICAL_TEXTURE_SLOTS.each do |slot|
+      define_method(:"#{slot}=") { |value| set_texture_slot(slot, value) }
+    end
+
+    def texture_slots
+      TEXTURE_SLOTS
+    end
+
+    def to_h
+      result = super.merge(
+        anisotropy: @anisotropy,
+        anisotropy_rotation: @anisotropy_rotation,
+        clearcoat: @clearcoat,
+        clearcoat_roughness: @clearcoat_roughness,
+        transmission: @transmission,
+        thickness: @thickness,
+        ior: @ior,
+        reflectivity: reflectivity,
+        iridescence: @iridescence,
+        iridescence_ior: @iridescence_ior,
+        iridescence_thickness_range: @iridescence_thickness_range&.dup,
+        sheen: @sheen,
+        sheen_color: @sheen_color.hex,
+        sheen_roughness: @sheen_roughness,
+        dispersion: @dispersion,
+        specular_intensity: @specular_intensity,
+        specular_color: @specular_color.hex,
+        attenuation_distance: @attenuation_distance,
+        attenuation_color: @attenuation_color.hex
+      )
+      PHYSICAL_TEXTURE_SLOTS.each { |slot| result[slot] = public_send(slot)&.to_h }
+      result
+    end
+
+    private
+
+    def bind_physical_color_changes
+      @sheen_color.on_change { mark_dirty!(:parameters) }
+      @specular_color.on_change { mark_dirty!(:parameters) }
+      @attenuation_color.on_change { mark_dirty!(:parameters) }
+    end
+  end
+end