stagecraft 1.0.0

data/lib/stagecraft/core/bounding.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Stagecraft
+  module Bounding
+    class Box3
+      attr_reader :min, :max
+
+      def initialize(min = nil, max = nil)
+        @min = min || Larb::Vec3.new(Float::INFINITY, Float::INFINITY, Float::INFINITY)
+        @max = max || Larb::Vec3.new(-Float::INFINITY, -Float::INFINITY, -Float::INFINITY)
+      end
+
+      def expand_by_point(point)
+        @min = min.min(point)
+        @max = max.max(point)
+        self
+      end
+
+      def empty?
+        min.x > max.x || min.y > max.y || min.z > max.z
+      end
+
+      def center
+        return Larb::Vec3.new if empty?
+
+        (min + max) * 0.5
+      end
+
+      def size
+        empty? ? Larb::Vec3.new : max - min
+      end
+
+      def intersects_ray?(origin, inverse_direction)
+        tmin = -Float::INFINITY
+        tmax = Float::INFINITY
+        3.times do |axis|
+          first = (min[axis] - origin[axis]) * inverse_direction[axis]
+          second = (max[axis] - origin[axis]) * inverse_direction[axis]
+          first, second = second, first if first > second
+          tmin = [tmin, first].max
+          tmax = [tmax, second].min
+          return false if tmax < [tmin, 0.0].max
+        end
+        true
+      end
+    end
+
+    class Sphere
+      attr_reader :center, :radius
+
+      def initialize(center = Larb::Vec3.new, radius = 0.0)
+        @center = center
+        @radius = radius.to_f
+      end
+
+      def transform(matrix)
+        elements = matrix.to_a
+        scale = [
+          Math.sqrt(elements[0]**2 + elements[1]**2 + elements[2]**2),
+          Math.sqrt(elements[4]**2 + elements[5]**2 + elements[6]**2),
+          Math.sqrt(elements[8]**2 + elements[9]**2 + elements[10]**2)
+        ].max
+        transformed = matrix * center.to_vec4(1.0)
+        self.class.new(transformed.xyz, radius * scale)
+      end
+
+      def intersects_ray?(origin, direction)
+        offset = center - origin
+        projected = offset.dot(direction)
+        distance_squared = offset.length_squared - (projected * projected)
+        return nil if distance_squared > radius * radius
+
+        half_chord = Math.sqrt((radius * radius) - distance_squared)
+        near = projected - half_chord
+        far = projected + half_chord
+        far.negative? ? nil : [near, 0.0].max
+      end
+    end
+
+    class Plane
+      attr_reader :normal, :constant
+
+      def initialize(normal, constant)
+        length = normal.length
+        raise ArgumentError, "plane normal cannot be zero" if length.zero?
+
+        @normal = normal / length
+        @constant = constant.to_f / length
+      end
+
+      def distance_to_point(point)
+        normal.dot(point) + constant
+      end
+
+      def intersects_sphere?(sphere)
+        distance_to_point(sphere.center) >= -sphere.radius
+      end
+    end
+
+    class Frustum
+      attr_reader :planes
+
+      def initialize(planes)
+        raise ArgumentError, "frustum requires six planes" unless planes.length == 6
+
+        @planes = planes.freeze
+      end
+
+      def self.from_matrix(matrix)
+        m = matrix.to_a
+        row = ->(index) { [m[index], m[index + 4], m[index + 8], m[index + 12]] }
+        r0, r1, r2, r3 = 4.times.map { |index| row.call(index) }
+        coefficients = [
+          combine(r3, r0, 1), combine(r3, r0, -1),
+          combine(r3, r1, 1), combine(r3, r1, -1),
+          r2, combine(r3, r2, -1)
+        ]
+        new(coefficients.map { |a, b, c, d| Plane.new(Larb::Vec3.new(a, b, c), d) })
+      end
+
+      def intersects_sphere?(sphere)
+        planes.all? { |plane| plane.intersects_sphere?(sphere) }
+      end
+
+      def self.combine(left, right, sign)
+        4.times.map { |index| left[index] + (right[index] * sign) }
+      end
+      private_class_method :combine
+    end
+  end
+end

data/lib/stagecraft/core/geometry.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Stagecraft
+  class Geometry
+    ATTRIBUTE_NAMES = %i[position normal uv uv1 tangent color joints weights].freeze
+
+    TOPOLOGIES = %i[point_list line_list line_strip triangle_list triangle_strip].freeze
+
+    attr_reader :index, :version, :topology
+
+    def initialize(topology: :triangle_list)
+      @attributes = {}
+      @index = nil
+      @version = 0
+      @disposed = false
+      @dispose_callbacks = []
+      @bounding_version = -1
+      self.topology = topology
+    end
+
+    def set_attribute(name, data:, format:, count:)
+      ensure_alive!
+      key = name.to_sym
+      raise ArgumentError, "unsupported attribute #{name.inspect}" unless ATTRIBUTE_NAMES.include?(key)
+
+      @attributes[key] = Attribute.new(data:, format:, count:) { changed! }
+      changed!
+      self
+    end
+
+    def delete_attribute(name)
+      return nil unless @attributes.delete(name.to_sym)
+
+      changed!
+    end
+
+    def attribute(name)
+      @attributes[name.to_sym]
+    end
+
+    def attributes
+      @attributes.dup.freeze
+    end
+
+    def set_index(data:, format:)
+      ensure_alive!
+      @index = IndexAttribute.new(data:, format:) { changed! }
+      changed!
+      self
+    end
+
+    def topology=(value)
+      next_value = value.to_sym
+      raise ArgumentError, "unsupported topology #{value.inspect}" unless TOPOLOGIES.include?(next_value)
+      return next_value if @topology == next_value
+
+      @topology = next_value
+      changed!
+      next_value
+    end
+
+    def bounding_box
+      refresh_bounds! if @bounding_version != version
+      @bounding_box
+    end
+
+    def bounding_sphere
+      refresh_bounds! if @bounding_version != version
+      @bounding_sphere
+    end
+
+    def compute_normals!
+      positions = position_values
+      normals = Array.new(positions.length) { Larb::Vec3.new }
+      triangle_indices.each_slice(3) do |a, b, c|
+        break unless c
+
+        face = (positions[b] - positions[a]).cross(positions[c] - positions[a])
+        normals[a] = normals[a] + face
+        normals[b] = normals[b] + face
+        normals[c] = normals[c] + face
+      end
+      packed = normals.flat_map { |normal| normal.length.zero? ? [0.0, 1.0, 0.0] : normal.normalize.to_a }.pack("e*")
+      set_attribute(:normal, data: packed, format: :float32x3, count: positions.length)
+    end
+
+    def on_dispose(&block)
+      @dispose_callbacks << block
+      self
+    end
+
+    def dispose
+      return self if @disposed
+
+      @disposed = true
+      @version += 1
+      @dispose_callbacks.each { |callback| callback.call(self) }
+      @dispose_callbacks.clear
+      self
+    end
+
+    def disposed?
+      @disposed
+    end
+
+    private
+
+    def ensure_alive!
+      raise DisposedError, "geometry has been disposed" if disposed?
+    end
+
+    def changed!
+      @version += 1
+      @bounding_version = -1
+      self
+    end
+
+    def position_values
+      position = attribute(:position)
+      raise Error, "geometry has no position attribute" unless position
+      raise Error, "bounding and normals require :float32x3 positions" unless position.format == :float32x3
+
+      position.data.unpack("e*").each_slice(3).map { |values| Larb::Vec3.new(*values) }
+    end
+
+    def triangle_indices
+      values = if index
+                 index.data.unpack(index.format == :uint16 ? "S<*" : "L<*")
+               else
+                 (0...position_values.length).to_a
+               end
+      return values if topology == :triangle_list
+      unless topology == :triangle_strip
+        raise Error, "normal computation requires triangle geometry, got #{topology}"
+      end
+      return [] if values.length < 3
+
+      (0..(values.length - 3)).flat_map do |offset|
+        a, b, c = values.slice(offset, 3)
+        offset.odd? ? [b, a, c] : [a, b, c]
+      end
+    end
+
+    def refresh_bounds!
+      positions = position_values
+      box = Bounding::Box3.new
+      positions.each { |point| box.expand_by_point(point) }
+      center = box.center
+      radius = positions.map { |point| point.distance(center) }.max || 0.0
+      @bounding_box = box
+      @bounding_sphere = Bounding::Sphere.new(center, radius)
+      @bounding_version = version
+    end
+  end
+end

data/lib/stagecraft/core/mesh.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Stagecraft
+  class Mesh < Node
+    attr_reader :geometry, :material
+    attr_accessor :frustum_culled, :skin, :morph_weights
+
+    def initialize(geometry, material, **)
+      super(**)
+      self.geometry = geometry
+      self.material = material
+      @frustum_culled = true
+      @morph_weights = []
+    end
+
+    def geometry=(value)
+      raise ArgumentError, "expected a Stagecraft::Geometry" unless value.is_a?(Geometry)
+
+      @geometry = value
+    end
+
+    def material=(value)
+      @material = value
+    end
+  end
+end

data/lib/stagecraft/core/node.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Stagecraft
+  class Node
+    attr_reader :position, :rotation, :scale, :children, :parent, :world_version
+    attr_accessor :name, :visible, :cast_shadow, :receive_shadow, :render_order
+
+    def initialize(name: nil)
+      @name = name
+      @visible = true
+      @cast_shadow = false
+      @receive_shadow = true
+      @render_order = 0
+      @children = []
+      @parent = nil
+      @local_revision = 0
+      @cached_local_revision = -1
+      @cached_parent_version = nil
+      @cached_parent_identity = nil
+      @world_version = 0
+      @position = ObservedVec3.new(self)
+      @rotation = ObservedQuat.new(self)
+      @scale = ObservedVec3.new(self, Larb::Vec3.one)
+      @local_matrix = Larb::Mat4.identity
+      @world_matrix = Larb::Mat4.identity
+    end
+
+    def add(*nodes)
+      nodes.flatten.each do |node|
+        validate_child!(node)
+        next if node.parent.equal?(self)
+
+        node.parent&.remove(node)
+        node.send(:parent=, self)
+        children << node
+      end
+      self
+    end
+
+    def remove(node)
+      return nil unless children.delete(node)
+
+      node.send(:parent=, nil)
+      node
+    end
+
+    def traverse(&block)
+      return enum_for(:traverse) unless block
+
+      block.call(self)
+      children.each { |child| child.traverse(&block) }
+      self
+    end
+
+    def find(target_name)
+      traverse.find { |node| node.name == target_name }
+    end
+
+    def local_matrix
+      return @local_matrix if @cached_local_revision == @local_revision
+
+      @local_matrix = compose_local_matrix
+      @cached_local_revision = @local_revision
+      @local_matrix
+    end
+
+    def world_matrix
+      world_matrix_with_version.first
+    end
+
+    def world_matrix_with_version
+      parent_matrix, parent_version = parent&.world_matrix_with_version
+      parent_identity = parent&.object_id
+      stale = @cached_local_revision != @local_revision ||
+              @cached_parent_version != parent_version ||
+              @cached_parent_identity != parent_identity
+      if stale
+        local = local_matrix
+        @world_matrix = parent_matrix ? parent_matrix * local : local
+        @cached_parent_version = parent_version
+        @cached_parent_identity = parent_identity
+        @world_version += 1
+      end
+      [@world_matrix, @world_version]
+    end
+
+    def world_position
+      world_matrix.extract_translation
+    end
+
+    def look_at(target, up: Larb::Vec3.up)
+      target_value = target.respond_to?(:to_larb) ? target.to_larb : target
+      eye = world_position
+      raise ArgumentError, "look_at target must differ from position" if eye == target_value
+
+      world_rotation = Larb::Mat4.look_at(eye, target_value, up).inverse.extract_rotation
+      local_rotation = if parent
+                         parent.world_matrix.extract_rotation.inverse * world_rotation
+                       else
+                         world_rotation
+                       end
+      rotation.set(local_rotation)
+      self
+    end
+
+    def transform_dirty!
+      @local_revision += 1
+      self
+    end
+
+    protected
+
+    def compose_local_matrix
+      Larb::Mat4.translation(*position.to_a) *
+        rotation.to_larb.to_mat4 *
+        Larb::Mat4.scaling(*scale.to_a)
+    end
+
+    private
+
+    def parent=(value)
+      @parent = value
+      @cached_parent_identity = nil
+      @cached_parent_version = nil
+    end
+
+    def validate_child!(node)
+      raise ArgumentError, "expected a Stagecraft::Node" unless node.is_a?(Node)
+      raise ArgumentError, "a node cannot parent itself" if node.equal?(self)
+      raise ArgumentError, "adding this node would create a cycle" if ancestor_of?(node)
+    end
+
+    def ancestor_of?(node)
+      current = self
+      while current
+        return true if current.equal?(node)
+
+        current = current.parent
+      end
+      false
+    end
+  end
+
+  class MatrixNode < Node
+    attr_reader :matrix
+
+    def initialize(matrix, **)
+      super(**)
+      self.matrix = matrix
+    end
+
+    def matrix=(value)
+      @matrix = value.is_a?(Larb::Mat4) ? value : Larb::Mat4.new(value.to_a)
+      transform_dirty!
+    end
+
+    protected
+
+    def compose_local_matrix
+      matrix
+    end
+  end
+end

data/lib/stagecraft/core/observed_value.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Stagecraft
+  class ObservedVec3
+    COMPONENTS = %i[x y z].freeze
+
+    def initialize(owner, value = Larb::Vec3.new)
+      @owner = owner
+      @value = coerce(value)
+    end
+
+    COMPONENTS.each_with_index do |component, index|
+      define_method(component) { @value.public_send(component) }
+      define_method(:"#{component}=") do |new_value|
+        return new_value if @value.public_send(component) == new_value.to_f
+
+        @value.public_send(:"#{component}=", new_value.to_f)
+        changed!
+        new_value
+      end
+    end
+
+    def set(x, y = nil, z = nil)
+      values = y.nil? && z.nil? ? vector_components(x) : [x, y, z]
+      return self if to_a == values.map(&:to_f)
+
+      @value = Larb::Vec3.new(*values)
+      changed!
+      self
+    end
+
+    def []=(index, value)
+      component = COMPONENTS.fetch(index)
+      public_send(:"#{component}=", value)
+    end
+
+    def [](index)
+      @value[index]
+    end
+
+    def normalize!
+      set(@value.normalize)
+    end
+
+    def to_larb
+      Larb::Vec3.new(*to_a)
+    end
+
+    def to_a
+      @value.to_a
+    end
+
+    def ==(other)
+      other.respond_to?(:to_a) && to_a == other.to_a
+    end
+
+    def inspect
+      "#{self.class.name}[#{to_a.join(", ")}]"
+    end
+
+    def method_missing(name, *arguments, **keywords, &block)
+      return super unless @value.respond_to?(name)
+
+      @value.public_send(name, *unwrap_arguments(*arguments), **keywords, &block)
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @value.respond_to?(name, include_private) || super
+    end
+
+    private
+
+    def changed!
+      @owner.transform_dirty!
+    end
+
+    def coerce(value)
+      Larb::Vec3.new(*vector_components(value))
+    end
+
+    def vector_components(value)
+      return value.to_a if value.respond_to?(:to_a)
+
+      Array(value)
+    end
+
+    def unwrap_arguments(*arguments)
+      arguments.map { |argument| argument.respond_to?(:to_larb) ? argument.to_larb : argument }
+    end
+  end
+
+  class ObservedQuat
+    COMPONENTS = %i[x y z w].freeze
+
+    def initialize(owner, value = Larb::Quat.new)
+      @owner = owner
+      @value = coerce(value)
+    end
+
+    COMPONENTS.each_with_index do |component, index|
+      define_method(component) { @value.public_send(component) }
+      define_method(:"#{component}=") do |new_value|
+        return new_value if @value[index] == new_value.to_f
+
+        @value.public_send(:"#{component}=", new_value.to_f)
+        changed!
+        new_value
+      end
+    end
+
+    def set(x, y = nil, z = nil, w = nil)
+      values = y.nil? && z.nil? && w.nil? ? x.to_a : [x, y, z, w]
+      next_value = Larb::Quat.new(*values).normalize
+      return self if @value == next_value
+
+      @value = next_value
+      changed!
+      self
+    end
+
+    def rotate_x!(angle)
+      rotate_axis!(Larb::Vec3.right, angle)
+    end
+
+    def rotate_y!(angle)
+      rotate_axis!(Larb::Vec3.up, angle)
+    end
+
+    def rotate_z!(angle)
+      rotate_axis!(Larb::Vec3.back, angle)
+    end
+
+    def slerp!(target, amount)
+      set(@value.slerp(coerce(target), amount))
+    end
+
+    def normalize!
+      set(@value.normalize)
+    end
+
+    def to_larb
+      Larb::Quat.new(*to_a)
+    end
+
+    def to_a
+      @value.to_a
+    end
+
+    def ==(other)
+      other.respond_to?(:to_a) && to_a == other.to_a
+    end
+
+    def inspect
+      "#{self.class.name}[#{to_a.join(", ")}]"
+    end
+
+    def method_missing(name, *arguments, **keywords, &block)
+      return super unless @value.respond_to?(name)
+
+      values = arguments.map { |argument| argument.respond_to?(:to_larb) ? argument.to_larb : argument }
+      @value.public_send(name, *values, **keywords, &block)
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @value.respond_to?(name, include_private) || super
+    end
+
+    private
+
+    def rotate_axis!(axis, angle)
+      set(@value * Larb::Quat.from_axis_angle(axis, angle.to_f))
+    end
+
+    def changed!
+      @owner.transform_dirty!
+    end
+
+    def coerce(value)
+      value.is_a?(Larb::Quat) ? value : Larb::Quat.new(*value.to_a)
+    end
+  end
+end

data/lib/stagecraft/core/raycaster.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Stagecraft
+  class Raycaster
+    Hit = Data.define(:object, :distance, :point)
+
+    attr_reader :origin, :direction, :near, :far
+
+    def initialize(origin: Larb::Vec3.new, direction: Larb::Vec3.forward, near: 0.0, far: Float::INFINITY)
+      @near = Float(near)
+      @far = Float(far)
+      raise ArgumentError, "ray near distance cannot be negative" if @near.negative?
+      raise ArgumentError, "ray far distance must not be less than near" if @far < @near
+
+      set(origin, direction)
+    end
+
+    def set(origin, direction)
+      @origin = vector(origin)
+      value = vector(direction)
+      raise ArgumentError, "ray direction cannot be zero" if value.length.zero?
+
+      @direction = value.normalize
+      self
+    end
+
+    def set_from_camera(ndc_x, ndc_y, camera)
+      inverse = camera.view_projection_matrix.inverse
+      near_point = unproject(inverse, ndc_x, ndc_y, 0.0)
+      far_point = unproject(inverse, ndc_x, ndc_y, 1.0)
+      ray_origin = camera.is_a?(Cameras::Perspective) ? camera.world_position : near_point
+      set(ray_origin, far_point - ray_origin)
+    end
+
+    def intersect(root, recursive: true)
+      nodes = recursive ? root.traverse : [root]
+      nodes.filter_map { |node| intersect_mesh(node) }.sort_by(&:distance)
+    end
+
+    private
+
+    def unproject(matrix, x, y, z)
+      value = matrix * Larb::Vec4.new(x, y, z, 1.0)
+      value.perspective_divide
+    end
+
+    def vector(value)
+      source = value.respond_to?(:to_larb) ? value.to_larb : value
+      Larb::Vec3.new(*source.to_a)
+    end
+
+    def intersect_mesh(node)
+      return unless node.is_a?(Mesh) && node.visible
+
+      sphere = node.geometry.bounding_sphere.transform(node.world_matrix)
+      distance = sphere.intersects_ray?(origin, direction)
+      return unless distance && distance >= near && distance <= far
+
+      Hit.new(object: node, distance:, point: origin + (direction * distance))
+    end
+  end
+end