3rb 0.1.0

data/lib/3rb/animation/animation_mixer.rb

@@ -0,0 +1,366 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class AnimationMixer
+    attr_reader :root, :time, :time_scale
+    attr_accessor :actions
+
+    def initialize(root)
+      @root = root
+      @actions = []
+      @time = 0
+      @time_scale = 1
+
+      @bindings = {}
+      @active_actions = []
+    end
+
+    def clip_action(clip, root: nil, blend_mode: nil)
+      target_root = root || @root
+
+      action = @actions.find { |a| a.clip == clip && a.root == target_root }
+      return action if action
+
+      action = AnimationAction.new(self, clip, target_root, blend_mode)
+      @actions << action
+      action
+    end
+
+    def existing_action(clip, root: nil)
+      target_root = root || @root
+      @actions.find { |a| a.clip == clip && a.root == target_root }
+    end
+
+    def stop_all_action
+      @actions.each(&:stop)
+      @active_actions.clear
+    end
+
+    def update(delta_time)
+      scaled_delta = delta_time * @time_scale
+      @time += scaled_delta
+
+      @active_actions.each do |action|
+        action.update(scaled_delta)
+      end
+    end
+
+    def set_time(time)
+      @time = time
+
+      @active_actions.each do |action|
+        action.time = time
+        action.apply
+      end
+    end
+
+    def get_root
+      @root
+    end
+
+    def uncache_clip(clip)
+      @actions.reject! { |a| a.clip == clip }
+    end
+
+    def uncache_root(root)
+      @actions.reject! { |a| a.root == root }
+    end
+
+    def uncache_action(clip, root: nil)
+      target_root = root || @root
+      @actions.reject! { |a| a.clip == clip && a.root == target_root }
+    end
+
+    def activate_action(action)
+      @active_actions << action unless @active_actions.include?(action)
+    end
+
+    def deactivate_action(action)
+      @active_actions.delete(action)
+    end
+
+    def get_binding(track_name, root)
+      key = "#{root.object_id}_#{track_name}"
+      @bindings[key] ||= PropertyBinding.new(root, track_name)
+    end
+  end
+
+  class AnimationAction
+    attr_accessor :loop, :repetitions, :clamp_when_finished
+    attr_accessor :paused, :enabled
+    attr_accessor :time, :time_scale, :weight
+    attr_accessor :zero_slope_at_start, :zero_slope_at_end
+
+    attr_reader :mixer, :clip, :root
+
+    LOOP_MODE = {
+      once: 2200,
+      repeat: 2201,
+      ping_pong: 2202
+    }.freeze
+
+    def initialize(mixer, clip, root = nil, blend_mode = nil)
+      @mixer = mixer
+      @clip = clip
+      @root = root || mixer.root
+      @blend_mode = blend_mode || clip.blend_mode
+
+      @loop = :repeat
+      @repetitions = Float::INFINITY
+
+      @paused = false
+      @enabled = true
+
+      @time = 0
+      @time_scale = 1
+      @weight = 1
+
+      @clamp_when_finished = false
+      @zero_slope_at_start = true
+      @zero_slope_at_end = true
+
+      @loop_count = -1
+      @start_time = nil
+
+      @bindings = clip.tracks.map do |track|
+        mixer.get_binding(track.name, @root)
+      end
+    end
+
+    def play
+      @mixer.activate_action(self)
+      self
+    end
+
+    def stop
+      @mixer.deactivate_action(self)
+      reset
+      self
+    end
+
+    def reset
+      @paused = false
+      @time = 0
+      @loop_count = -1
+      @start_time = nil
+      self
+    end
+
+    def is_running
+      @enabled && !@paused && @time_scale != 0 && @start_time.nil? &&
+        @mixer.instance_variable_get(:@active_actions).include?(self)
+    end
+
+    def is_scheduled
+      @mixer.instance_variable_get(:@active_actions).include?(self)
+    end
+
+    def start_at(time)
+      @start_time = time
+      self
+    end
+
+    def set_loop(mode, repetitions = Float::INFINITY)
+      @loop = mode
+      @repetitions = repetitions
+      self
+    end
+
+    def set_effective_time_scale(time_scale)
+      @time_scale = time_scale
+      self
+    end
+
+    def set_effective_weight(weight)
+      @weight = weight
+      self
+    end
+
+    def set_duration(duration)
+      @time_scale = @clip.duration / duration
+      self
+    end
+
+    def sync_with(action)
+      @time = action.time
+      @time_scale = action.time_scale
+      self
+    end
+
+    def halt(duration)
+      set_effective_weight(0) if duration == 0
+      self
+    end
+
+    def warp(start_time_scale, end_time_scale, duration)
+      @time_scale = start_time_scale
+      self
+    end
+
+    def crossfade_from(fade_out_action, duration, warp)
+      fade_out_action.fade_out(duration)
+      fade_in(duration)
+
+      if warp
+        fade_out_scale = fade_out_action.clip.duration / @clip.duration
+        fade_out_action.warp(1.0, fade_out_scale, duration)
+        warp(fade_out_scale, 1.0, duration)
+      end
+
+      self
+    end
+
+    def crossfade_to(fade_in_action, duration, warp)
+      fade_in_action.crossfade_from(self, duration, warp)
+    end
+
+    def fade_in(duration)
+      @weight = 0 if duration > 0
+      self
+    end
+
+    def fade_out(duration)
+      self
+    end
+
+    def update(delta)
+      return if @paused || !@enabled
+
+      if @start_time
+        return if @mixer.time < @start_time
+
+        @start_time = nil
+      end
+
+      @time += delta * @time_scale
+
+      apply
+    end
+
+    def apply
+      duration = @clip.duration
+      local_time = @time % duration
+      local_time = duration + local_time if local_time < 0
+
+      effective_weight = @weight
+
+      @clip.tracks.each_with_index do |track, i|
+        value = track.get_value_at_time(local_time)
+        binding = @bindings[i]
+        binding&.set_value(value, effective_weight, @blend_mode)
+      end
+    end
+
+    def get_effective_time_scale
+      @time_scale
+    end
+
+    def get_effective_weight
+      @weight
+    end
+
+    def get_clip
+      @clip
+    end
+
+    def get_mixer
+      @mixer
+    end
+
+    def get_root
+      @root
+    end
+  end
+
+  class PropertyBinding
+    attr_reader :root, :path
+
+    def initialize(root, path)
+      @root = root
+      @path = path
+
+      parse_path
+    end
+
+    def get_value
+      target = resolve_target
+      return nil unless target
+
+      if @property_index
+        target.send(@property_name)[@property_index]
+      else
+        target.send(@property_name)
+      end
+    end
+
+    def set_value(value, weight = 1.0, blend_mode = :normal)
+      target = resolve_target
+      return unless target
+
+      if value.is_a?(Array)
+        obj = target.send(@property_name)
+
+        case obj
+        when Vector2
+          obj.set(value[0], value[1])
+        when Vector3
+          obj.set(value[0], value[1], value[2])
+        when Vector4, Quaternion
+          obj.set(value[0], value[1], value[2], value[3])
+        when Color
+          obj.set_rgb(value[0], value[1], value[2])
+        when Euler
+          obj.set(value[0], value[1], value[2])
+        end
+      else
+        if @property_index
+          obj = target.send(@property_name)
+          obj[@property_index] = value
+        elsif target.respond_to?("#{@property_name}=")
+          target.send("#{@property_name}=", value)
+        end
+      end
+    end
+
+    private
+
+    def parse_path
+      parts = @path.split(".")
+
+      @node_name = nil
+      @property_name = nil
+      @property_index = nil
+
+      if parts.first&.match?(/^\[.+\]$/)
+        @node_name = parts.shift[1..-2]
+      end
+
+      if parts.last&.match?(/\[(\d+)\]$/)
+        match = parts.last.match(/(.+)\[(\d+)\]$/)
+        parts[-1] = match[1]
+        @property_index = match[2].to_i
+      end
+
+      @object_names = parts[0..-2]
+      @property_name = parts.last
+    end
+
+    def resolve_target
+      target = @root
+
+      if @node_name && target.respond_to?(:get_object_by_name)
+        target = target.get_object_by_name(@node_name) || target
+      end
+
+      @object_names&.each do |name|
+        if target.respond_to?(name)
+          target = target.send(name)
+        else
+          return nil
+        end
+      end
+
+      target
+    end
+  end
+end

data/lib/3rb/cameras/camera.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class Camera < Object3D
+    attr_reader :matrix_world_inverse, :projection_matrix, :projection_matrix_inverse
+
+    def initialize
+      super
+      @matrix_world_inverse = Matrix4.new
+      @projection_matrix = Matrix4.new
+      @projection_matrix_inverse = Matrix4.new
+    end
+
+    def update_matrix_world(force = false)
+      super
+      @matrix_world_inverse.copy(@matrix_world).invert!
+    end
+
+    def update_world_matrix(update_parents, update_children)
+      super
+      @matrix_world_inverse.copy(@matrix_world).invert!
+    end
+
+    def update_projection_matrix
+      raise NotImplementedError, "Subclasses must implement update_projection_matrix"
+    end
+
+    def clone(recursive = true)
+      new_camera = super
+      new_camera.matrix_world_inverse.copy(@matrix_world_inverse)
+      new_camera.projection_matrix.copy(@projection_matrix)
+      new_camera.projection_matrix_inverse.copy(@projection_matrix_inverse)
+      new_camera
+    end
+
+    def copy(source, recursive = true)
+      super
+      @matrix_world_inverse.copy(source.matrix_world_inverse)
+      @projection_matrix.copy(source.projection_matrix)
+      @projection_matrix_inverse.copy(source.projection_matrix_inverse)
+      self
+    end
+
+    def to_h
+      super.merge(
+        projection_matrix: @projection_matrix.elements
+      )
+    end
+  end
+end

data/lib/3rb/cameras/orthographic_camera.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class OrthographicCamera < Camera
+    attr_accessor :left, :right, :top, :bottom, :near, :far, :zoom
+
+    def initialize(left: -1, right: 1, top: 1, bottom: -1, near: 0.1, far: 2000)
+      super()
+      @left = left.to_f
+      @right = right.to_f
+      @top = top.to_f
+      @bottom = bottom.to_f
+      @near = near.to_f
+      @far = far.to_f
+      @zoom = 1.0
+      update_projection_matrix
+    end
+
+    def update_projection_matrix
+      dx = (@right - @left) / (2 * @zoom)
+      dy = (@top - @bottom) / (2 * @zoom)
+      cx = (@right + @left) / 2
+      cy = (@top + @bottom) / 2
+
+      @projection_matrix.make_orthographic(
+        cx - dx,
+        cx + dx,
+        cy + dy,
+        cy - dy,
+        @near,
+        @far
+      )
+
+      @projection_matrix_inverse.copy(@projection_matrix).invert!
+    end
+
+    def set_view_offset(full_width, full_height, x, y, width, height)
+      @view = {
+        full_width: full_width,
+        full_height: full_height,
+        offset_x: x,
+        offset_y: y,
+        width: width,
+        height: height
+      }
+      update_projection_matrix
+    end
+
+    def clear_view_offset
+      @view = nil
+      update_projection_matrix
+    end
+
+    def clone(recursive = true)
+      new_camera = super
+      new_camera.left = @left
+      new_camera.right = @right
+      new_camera.top = @top
+      new_camera.bottom = @bottom
+      new_camera.near = @near
+      new_camera.far = @far
+      new_camera.zoom = @zoom
+      new_camera.update_projection_matrix
+      new_camera
+    end
+
+    def copy(source, recursive = true)
+      super
+      @left = source.left
+      @right = source.right
+      @top = source.top
+      @bottom = source.bottom
+      @near = source.near
+      @far = source.far
+      @zoom = source.zoom
+      update_projection_matrix
+      self
+    end
+
+    def to_h
+      super.merge(
+        left: @left,
+        right: @right,
+        top: @top,
+        bottom: @bottom,
+        near: @near,
+        far: @far,
+        zoom: @zoom
+      )
+    end
+  end
+end

data/lib/3rb/cameras/perspective_camera.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class PerspectiveCamera < Camera
+    attr_accessor :fov, :aspect, :near, :far, :focus, :zoom
+    attr_accessor :film_gauge, :film_offset
+
+    def initialize(fov: 50, aspect: 1, near: 0.1, far: 2000)
+      super()
+      @fov = fov.to_f
+      @aspect = aspect.to_f
+      @near = near.to_f
+      @far = far.to_f
+      @zoom = 1.0
+      @focus = 10.0
+      @film_gauge = 35.0
+      @film_offset = 0.0
+      update_projection_matrix
+    end
+
+    def set_focal_length(focal_length)
+      fov = 2 * MathUtils::RAD2DEG * Math.atan(@film_gauge / (focal_length * 2))
+      @fov = fov
+      update_projection_matrix
+    end
+
+    def get_focal_length
+      v_extent_slope = Math.tan(MathUtils::DEG2RAD * 0.5 * @fov) / @zoom
+      @film_gauge / (2 * v_extent_slope)
+    end
+
+    def get_effective_fov
+      MathUtils::RAD2DEG * 2 * Math.atan(Math.tan(MathUtils::DEG2RAD * 0.5 * @fov) / @zoom)
+    end
+
+    def get_film_width
+      @film_gauge * [@aspect, 1].min
+    end
+
+    def get_film_height
+      @film_gauge / [@aspect, 1].max
+    end
+
+    def update_projection_matrix
+      top = @near * Math.tan(MathUtils::DEG2RAD * 0.5 * @fov) / @zoom
+      height = 2 * top
+      width = @aspect * height
+      left = -0.5 * width
+
+      skew = @film_offset
+      left += @near * skew / get_film_width unless skew.zero?
+
+      @projection_matrix.make_perspective_bounds(
+        left,
+        left + width,
+        top,
+        top - height,
+        @near,
+        @far
+      )
+
+      @projection_matrix_inverse.copy(@projection_matrix).invert!
+    end
+
+    def clone(recursive = true)
+      new_camera = super
+      new_camera.fov = @fov
+      new_camera.aspect = @aspect
+      new_camera.near = @near
+      new_camera.far = @far
+      new_camera.zoom = @zoom
+      new_camera.focus = @focus
+      new_camera.film_gauge = @film_gauge
+      new_camera.film_offset = @film_offset
+      new_camera.update_projection_matrix
+      new_camera
+    end
+
+    def copy(source, recursive = true)
+      super
+      @fov = source.fov
+      @aspect = source.aspect
+      @near = source.near
+      @far = source.far
+      @zoom = source.zoom
+      @focus = source.focus
+      @film_gauge = source.film_gauge
+      @film_offset = source.film_offset
+      update_projection_matrix
+      self
+    end
+
+    def to_h
+      super.merge(
+        fov: @fov,
+        aspect: @aspect,
+        near: @near,
+        far: @far,
+        zoom: @zoom
+      )
+    end
+  end
+end