3rb 0.1.0

data/lib/3rb/lights/spot_light.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class SpotLight < Light
+    attr_accessor :target
+    attr_accessor :distance, :angle, :penumbra, :decay
+    attr_accessor :shadow
+    attr_accessor :map
+
+    def initialize(color: 0xffffff, intensity: 1.0,
+                   distance: 0, angle: Math::PI / 3, penumbra: 0, decay: 2)
+      super(color: color, intensity: intensity)
+      @target = Object3D.new
+      @distance = distance.to_f
+      @angle = angle.to_f
+      @penumbra = penumbra.to_f
+      @decay = decay.to_f
+      @map = nil
+      @shadow = SpotLightShadow.new
+    end
+
+    def power
+      @intensity * Math::PI
+    end
+
+    def power=(value)
+      @intensity = value / Math::PI
+    end
+
+    def copy(source, recursive = true)
+      super
+      @target = source.target.clone
+      @distance = source.distance
+      @angle = source.angle
+      @penumbra = source.penumbra
+      @decay = source.decay
+      @map = source.map
+      @shadow = source.shadow.clone
+      self
+    end
+
+    def clone(recursive = true)
+      self.class.new.copy(self, recursive)
+    end
+
+    def dispose
+      @shadow&.dispose
+    end
+
+    def to_h
+      super.merge(
+        target: @target.position.to_a,
+        distance: @distance,
+        angle: @angle,
+        penumbra: @penumbra,
+        decay: @decay
+      )
+    end
+  end
+
+  class SpotLightShadow
+    attr_accessor :camera, :bias, :normal_bias, :radius
+    attr_accessor :map_size, :focus
+
+    def initialize
+      @camera = PerspectiveCamera.new(fov: 50, aspect: 1, near: 0.5, far: 500)
+      @bias = 0
+      @normal_bias = 0
+      @radius = 1
+      @map_size = Vector2.new(512, 512)
+      @focus = 1
+    end
+
+    def clone
+      shadow = SpotLightShadow.new
+      shadow.camera = @camera.clone
+      shadow.bias = @bias
+      shadow.normal_bias = @normal_bias
+      shadow.radius = @radius
+      shadow.map_size = @map_size.clone
+      shadow.focus = @focus
+      shadow
+    end
+
+    def dispose
+    end
+  end
+end

data/lib/3rb/loaders/gltf_loader.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+require "json"
+require "base64"
+
+module Sunrb
+  class GLTFLoader < Loader
+    COMPONENT_TYPES = {
+      5120 => :byte,
+      5121 => :unsigned_byte,
+      5122 => :short,
+      5123 => :unsigned_short,
+      5125 => :unsigned_int,
+      5126 => :float
+    }.freeze
+
+    COMPONENT_SIZES = {
+      5120 => 1, 5121 => 1,
+      5122 => 2, 5123 => 2,
+      5125 => 4, 5126 => 4
+    }.freeze
+
+    TYPE_COUNTS = {
+      "SCALAR" => 1,
+      "VEC2" => 2,
+      "VEC3" => 3,
+      "VEC4" => 4,
+      "MAT2" => 4,
+      "MAT3" => 9,
+      "MAT4" => 16
+    }.freeze
+
+    def load(url, on_load: nil, on_progress: nil, on_error: nil)
+      full_path = resolve_path(url)
+
+      @manager.item_start(full_path)
+
+      begin
+        @base_path = File.dirname(full_path)
+        content = File.read(full_path)
+        json = JSON.parse(content, symbolize_names: true)
+
+        result = parse(json)
+
+        @manager.item_end(full_path)
+        on_load&.call(result)
+
+        result
+      rescue StandardError => e
+        @manager.item_error(full_path)
+        on_error&.call(e)
+        nil
+      end
+    end
+
+    def parse(json)
+      @json = json
+      @buffers = load_buffers
+      @accessors = parse_accessors
+      @materials = parse_materials
+      @meshes = parse_meshes
+      @nodes = parse_nodes
+      @scenes = parse_scenes
+
+      {
+        scene: @scenes[@json[:scene] || 0],
+        scenes: @scenes,
+        animations: parse_animations,
+        cameras: parse_cameras,
+        asset: @json[:asset]
+      }
+    end
+
+    private
+
+    def resolve_path(url)
+      if url.start_with?("/") || url.match?(%r{^https?://})
+        url
+      else
+        File.join(@path, url)
+      end
+    end
+
+    def load_buffers
+      (@json[:buffers] || []).map do |buffer|
+        if buffer[:uri]&.start_with?("data:")
+          decode_data_uri(buffer[:uri])
+        elsif buffer[:uri]
+          File.binread(File.join(@base_path, buffer[:uri]))
+        else
+          ""
+        end
+      end
+    end
+
+    def decode_data_uri(uri)
+      match = uri.match(%r{data:[^;]*;base64,(.*)})
+      match ? Base64.decode64(match[1]) : ""
+    end
+
+    def parse_accessors
+      (@json[:accessors] || []).map do |accessor|
+        buffer_view = @json[:bufferViews][accessor[:bufferView]]
+        buffer = @buffers[buffer_view[:buffer]]
+
+        offset = (buffer_view[:byteOffset] || 0) + (accessor[:byteOffset] || 0)
+        count = accessor[:count]
+        type_count = TYPE_COUNTS[accessor[:type]]
+        component_size = COMPONENT_SIZES[accessor[:componentType]]
+
+        stride = buffer_view[:byteStride] || (type_count * component_size)
+
+        data = []
+        count.times do |i|
+          pos = offset + i * stride
+          type_count.times do |j|
+            value = unpack_component(buffer, pos + j * component_size, accessor[:componentType])
+            data << value
+          end
+        end
+
+        {
+          data: data,
+          count: count,
+          type: accessor[:type],
+          component_type: accessor[:componentType],
+          item_size: type_count
+        }
+      end
+    end
+
+    def unpack_component(buffer, offset, component_type)
+      bytes = buffer[offset, COMPONENT_SIZES[component_type]]
+      return 0 unless bytes
+
+      case component_type
+      when 5126 then bytes.unpack1("e")
+      when 5125 then bytes.unpack1("V")
+      when 5123 then bytes.unpack1("v")
+      when 5122 then bytes.unpack1("s<")
+      when 5121 then bytes.unpack1("C")
+      when 5120 then bytes.unpack1("c")
+      else 0
+      end
+    end
+
+    def parse_materials
+      (@json[:materials] || []).map do |mat|
+        pbr = mat[:pbrMetallicRoughness] || {}
+
+        base_color = pbr[:baseColorFactor] || [1, 1, 1, 1]
+
+        MeshStandardMaterial.new(
+          color: Color.new(base_color[0], base_color[1], base_color[2]),
+          metalness: pbr[:metallicFactor] || 1.0,
+          roughness: pbr[:roughnessFactor] || 1.0,
+          opacity: base_color[3],
+          transparent: base_color[3] < 1.0,
+          name: mat[:name] || ""
+        )
+      end
+    end
+
+    def parse_meshes
+      (@json[:meshes] || []).map do |mesh|
+        primitives = mesh[:primitives].map do |prim|
+          geometry = BufferGeometry.new
+
+          prim[:attributes].each do |attr_name, accessor_idx|
+            accessor = @accessors[accessor_idx]
+            attribute_name = convert_attribute_name(attr_name.to_s)
+            geometry.set_attribute(
+              attribute_name,
+              Float32BufferAttribute.new(accessor[:data], accessor[:item_size])
+            )
+          end
+
+          if prim[:indices]
+            accessor = @accessors[prim[:indices]]
+            geometry.set_index(accessor[:data])
+          end
+
+          material = prim[:material] ? @materials[prim[:material]] : MeshStandardMaterial.new
+
+          Mesh.new(geometry, material)
+        end
+
+        { name: mesh[:name], primitives: primitives }
+      end
+    end
+
+    def convert_attribute_name(name)
+      case name
+      when "POSITION" then :position
+      when "NORMAL" then :normal
+      when "TEXCOORD_0" then :uv
+      when "TEXCOORD_1" then :uv2
+      when "COLOR_0" then :color
+      when "TANGENT" then :tangent
+      when "JOINTS_0" then :skinIndex
+      when "WEIGHTS_0" then :skinWeight
+      else name.downcase.to_sym
+      end
+    end
+
+    def parse_nodes
+      (@json[:nodes] || []).map.with_index do |node, idx|
+        obj = if node[:mesh]
+                mesh_data = @meshes[node[:mesh]]
+                if mesh_data[:primitives].length == 1
+                  mesh_data[:primitives].first
+                else
+                  group = Group.new
+                  mesh_data[:primitives].each { |p| group.add(p) }
+                  group
+                end
+              else
+                Object3D.new
+              end
+
+        obj.name = node[:name] || "node_#{idx}"
+
+        if node[:translation]
+          obj.position.set(*node[:translation])
+        end
+
+        if node[:rotation]
+          obj.quaternion.set(*node[:rotation])
+        end
+
+        if node[:scale]
+          obj.scale.set(*node[:scale])
+        end
+
+        if node[:matrix]
+          m = Matrix4.new
+          m.from_array(node[:matrix])
+          m.decompose(obj.position, obj.quaternion, obj.scale)
+        end
+
+        { object: obj, children: node[:children] || [] }
+      end
+    end
+
+    def parse_scenes
+      (@json[:scenes] || []).map do |scene_data|
+        scene = Scene.new
+        scene.name = scene_data[:name] || ""
+
+        (scene_data[:nodes] || []).each do |node_idx|
+          add_node_to_parent(scene, node_idx)
+        end
+
+        scene
+      end
+    end
+
+    def add_node_to_parent(parent, node_idx)
+      node_data = @nodes[node_idx]
+      return unless node_data
+
+      obj = node_data[:object]
+      parent.add(obj)
+
+      node_data[:children].each do |child_idx|
+        add_node_to_parent(obj, child_idx)
+      end
+    end
+
+    def parse_animations
+      (@json[:animations] || []).map do |anim|
+        {
+          name: anim[:name] || "",
+          channels: anim[:channels],
+          samplers: anim[:samplers]
+        }
+      end
+    end
+
+    def parse_cameras
+      (@json[:cameras] || []).map do |cam|
+        if cam[:type] == "perspective"
+          p = cam[:perspective]
+          PerspectiveCamera.new(
+            fov: (p[:yfov] * 180 / Math::PI),
+            aspect: p[:aspectRatio] || 1.0,
+            near: p[:znear],
+            far: p[:zfar] || 2000
+          )
+        else
+          o = cam[:orthographic]
+          OrthographicCamera.new(
+            left: -o[:xmag],
+            right: o[:xmag],
+            top: o[:ymag],
+            bottom: -o[:ymag],
+            near: o[:znear],
+            far: o[:zfar]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/3rb/loaders/loader.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class Loader
+    attr_accessor :manager, :path, :resource_path, :cross_origin
+    attr_accessor :with_credentials, :request_header
+
+    def initialize(manager: nil)
+      @manager = manager || DefaultLoadingManager
+      @path = ""
+      @resource_path = ""
+      @cross_origin = "anonymous"
+      @with_credentials = false
+      @request_header = {}
+    end
+
+    def set_path(path)
+      @path = path
+      self
+    end
+
+    def set_resource_path(path)
+      @resource_path = path
+      self
+    end
+
+    def set_cross_origin(cross_origin)
+      @cross_origin = cross_origin
+      self
+    end
+
+    def set_with_credentials(value)
+      @with_credentials = value
+      self
+    end
+
+    def set_request_header(header)
+      @request_header = header
+      self
+    end
+  end
+
+  class LoadingManager
+    attr_accessor :on_start, :on_load, :on_progress, :on_error
+    attr_accessor :url_modifier
+
+    def initialize(on_load: nil, on_progress: nil, on_error: nil)
+      @is_loading = false
+      @items_loaded = 0
+      @items_total = 0
+      @url_modifier = nil
+
+      @on_start = nil
+      @on_load = on_load
+      @on_progress = on_progress
+      @on_error = on_error
+    end
+
+    def item_start(url)
+      @items_total += 1
+
+      unless @is_loading
+        @on_start&.call(url, @items_loaded, @items_total)
+      end
+
+      @is_loading = true
+    end
+
+    def item_end(url)
+      @items_loaded += 1
+      @on_progress&.call(url, @items_loaded, @items_total)
+
+      if @items_loaded == @items_total
+        @is_loading = false
+        @on_load&.call
+      end
+    end
+
+    def item_error(url)
+      @on_error&.call(url)
+    end
+
+    def resolve_url(url)
+      @url_modifier ? @url_modifier.call(url) : url
+    end
+
+    def set_url_modifier(callback)
+      @url_modifier = callback
+      self
+    end
+  end
+
+  DefaultLoadingManager = LoadingManager.new
+end

data/lib/3rb/loaders/obj_loader.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class OBJLoader < Loader
+    def load(url, on_load: nil, on_progress: nil, on_error: nil)
+      full_path = resolve_path(url)
+
+      @manager.item_start(full_path)
+
+      begin
+        content = File.read(full_path)
+        result = parse(content)
+
+        @manager.item_end(full_path)
+        on_load&.call(result)
+
+        result
+      rescue StandardError => e
+        @manager.item_error(full_path)
+        on_error&.call(e)
+        nil
+      end
+    end
+
+    def parse(text)
+      group = Group.new
+
+      vertices = []
+      normals = []
+      uvs = []
+
+      current_object = nil
+      current_material = nil
+
+      objects = []
+      materials = {}
+
+      text.each_line do |line|
+        line = line.strip
+        next if line.empty? || line.start_with?("#")
+
+        parts = line.split(/\s+/)
+        keyword = parts.shift
+
+        case keyword
+        when "o", "g"
+          current_object = {
+            name: parts.join(" "),
+            vertices: [],
+            normals: [],
+            uvs: [],
+            faces: []
+          }
+          objects << current_object
+
+        when "v"
+          vertices << parts[0..2].map(&:to_f)
+
+        when "vn"
+          normals << parts[0..2].map(&:to_f)
+
+        when "vt"
+          uvs << parts[0..1].map(&:to_f)
+
+        when "f"
+          current_object ||= { name: "", vertices: [], normals: [], uvs: [], faces: [] }
+          objects << current_object unless objects.include?(current_object)
+
+          face = parse_face(parts, vertices, normals, uvs)
+          current_object[:faces] << face.merge(material: current_material)
+
+        when "usemtl"
+          current_material = parts.first
+
+        when "mtllib"
+          # Material library reference - stored for external loading
+          materials[:library] = parts.first
+        end
+      end
+
+      objects.each do |obj|
+        mesh = build_mesh(obj)
+        mesh.name = obj[:name]
+        group.add(mesh)
+      end
+
+      group.user_data[:materials] = materials
+      group
+    end
+
+    private
+
+    def resolve_path(url)
+      if url.start_with?("/") || url.match?(%r{^https?://})
+        url
+      else
+        File.join(@path, url)
+      end
+    end
+
+    def parse_face(parts, vertices, normals, uvs)
+      face_vertices = []
+      face_normals = []
+      face_uvs = []
+
+      parts.each do |part|
+        indices = part.split("/").map { |i| i.empty? ? nil : i.to_i }
+
+        v_idx = indices[0]
+        vt_idx = indices[1]
+        vn_idx = indices[2]
+
+        if v_idx
+          idx = v_idx > 0 ? v_idx - 1 : vertices.length + v_idx
+          face_vertices << vertices[idx] if vertices[idx]
+        end
+
+        if vt_idx
+          idx = vt_idx > 0 ? vt_idx - 1 : uvs.length + vt_idx
+          face_uvs << uvs[idx] if uvs[idx]
+        end
+
+        if vn_idx
+          idx = vn_idx > 0 ? vn_idx - 1 : normals.length + vn_idx
+          face_normals << normals[idx] if normals[idx]
+        end
+      end
+
+      { vertices: face_vertices, normals: face_normals, uvs: face_uvs }
+    end
+
+    def build_mesh(obj)
+      positions = []
+      mesh_normals = []
+      mesh_uvs = []
+      indices = []
+
+      vertex_map = {}
+      index = 0
+
+      obj[:faces].each do |face|
+        face_indices = []
+
+        face[:vertices].each_with_index do |v, i|
+          n = face[:normals][i] || [0, 0, 1]
+          uv = face[:uvs][i] || [0, 0]
+
+          key = "#{v.join(",")}_#{n.join(",")}_#{uv.join(",")}"
+
+          if vertex_map[key]
+            face_indices << vertex_map[key]
+          else
+            positions.concat(v)
+            mesh_normals.concat(n)
+            mesh_uvs.concat(uv)
+            vertex_map[key] = index
+            face_indices << index
+            index += 1
+          end
+        end
+
+        triangulate(face_indices).each { |tri| indices.concat(tri) }
+      end
+
+      geometry = BufferGeometry.new
+      geometry.set_attribute(:position, Float32BufferAttribute.new(positions, 3))
+      geometry.set_attribute(:normal, Float32BufferAttribute.new(mesh_normals, 3))
+      geometry.set_attribute(:uv, Float32BufferAttribute.new(mesh_uvs, 2))
+      geometry.set_index(indices)
+
+      material = MeshStandardMaterial.new
+
+      Mesh.new(geometry, material)
+    end
+
+    def triangulate(face_indices)
+      return [] if face_indices.length < 3
+
+      triangles = []
+      (1...face_indices.length - 1).each do |i|
+        triangles << [face_indices[0], face_indices[i], face_indices[i + 1]]
+      end
+      triangles
+    end
+  end
+end

data/lib/3rb/loaders/texture_loader.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class TextureLoader < Loader
+    def load(url, on_load: nil, on_progress: nil, on_error: nil)
+      texture = Texture.new
+
+      full_path = resolve_path(url)
+
+      @manager.item_start(full_path)
+
+      begin
+        image_data = load_image(full_path)
+        texture.image = image_data
+        texture.needs_update = true
+
+        @manager.item_end(full_path)
+        on_load&.call(texture)
+      rescue StandardError => e
+        @manager.item_error(full_path)
+        on_error&.call(e)
+        return nil
+      end
+
+      texture
+    end
+
+    def load_async(url)
+      Thread.new { load(url) }
+    end
+
+    private
+
+    def resolve_path(url)
+      if url.start_with?("/") || url.match?(%r{^https?://})
+        url
+      else
+        File.join(@path, url)
+      end
+    end
+
+    def load_image(path)
+      raise LoaderError, "File not found: #{path}" unless File.exist?(path)
+
+      {
+        path: path,
+        data: File.binread(path),
+        width: nil,
+        height: nil
+      }
+    end
+  end
+
+  class LoaderError < StandardError; end
+end