bevy 1.0.0

data/lib/bevy/audio_effects.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module Bevy
+  class AudioEffect
+    attr_accessor :enabled, :mix
+
+    def initialize(enabled: true, mix: 1.0)
+      @enabled = enabled
+      @mix = mix.to_f
+    end
+
+    def type_name
+      'AudioEffect'
+    end
+  end
+
+  class Reverb < AudioEffect
+    attr_accessor :room_size, :damping, :wet_level, :dry_level, :width
+
+    def initialize(
+      room_size: 0.5,
+      damping: 0.5,
+      wet_level: 0.33,
+      dry_level: 0.4,
+      width: 1.0,
+      **kwargs
+    )
+      super(**kwargs)
+      @room_size = room_size.to_f
+      @damping = damping.to_f
+      @wet_level = wet_level.to_f
+      @dry_level = dry_level.to_f
+      @width = width.to_f
+    end
+
+    def type_name
+      'Reverb'
+    end
+  end
+
+  class Delay < AudioEffect
+    attr_accessor :delay_time, :feedback, :wet_level
+
+    def initialize(delay_time: 0.5, feedback: 0.5, wet_level: 0.5, **kwargs)
+      super(**kwargs)
+      @delay_time = delay_time.to_f
+      @feedback = feedback.to_f
+      @wet_level = wet_level.to_f
+    end
+
+    def type_name
+      'Delay'
+    end
+  end
+
+  class LowPassFilter < AudioEffect
+    attr_accessor :cutoff, :resonance
+
+    def initialize(cutoff: 1000.0, resonance: 0.707, **kwargs)
+      super(**kwargs)
+      @cutoff = cutoff.to_f
+      @resonance = resonance.to_f
+    end
+
+    def type_name
+      'LowPassFilter'
+    end
+  end
+
+  class HighPassFilter < AudioEffect
+    attr_accessor :cutoff, :resonance
+
+    def initialize(cutoff: 200.0, resonance: 0.707, **kwargs)
+      super(**kwargs)
+      @cutoff = cutoff.to_f
+      @resonance = resonance.to_f
+    end
+
+    def type_name
+      'HighPassFilter'
+    end
+  end
+
+  class Compressor < AudioEffect
+    attr_accessor :threshold, :ratio, :attack, :release, :makeup_gain
+
+    def initialize(
+      threshold: -20.0,
+      ratio: 4.0,
+      attack: 0.01,
+      release: 0.1,
+      makeup_gain: 0.0,
+      **kwargs
+    )
+      super(**kwargs)
+      @threshold = threshold.to_f
+      @ratio = ratio.to_f
+      @attack = attack.to_f
+      @release = release.to_f
+      @makeup_gain = makeup_gain.to_f
+    end
+
+    def type_name
+      'Compressor'
+    end
+  end
+
+  class Equalizer < AudioEffect
+    attr_reader :bands
+
+    def initialize(**kwargs)
+      super(**kwargs)
+      @bands = []
+    end
+
+    def add_band(frequency:, gain:, q: 1.0)
+      @bands << EqualizerBand.new(frequency: frequency, gain: gain, q: q)
+      self
+    end
+
+    def type_name
+      'Equalizer'
+    end
+  end
+
+  class EqualizerBand
+    attr_accessor :frequency, :gain, :q
+
+    def initialize(frequency:, gain:, q: 1.0)
+      @frequency = frequency.to_f
+      @gain = gain.to_f
+      @q = q.to_f
+    end
+
+    def type_name
+      'EqualizerBand'
+    end
+  end
+
+  class Chorus < AudioEffect
+    attr_accessor :rate, :depth, :delay, :feedback
+
+    def initialize(rate: 1.5, depth: 0.02, delay: 0.03, feedback: 0.25, **kwargs)
+      super(**kwargs)
+      @rate = rate.to_f
+      @depth = depth.to_f
+      @delay = delay.to_f
+      @feedback = feedback.to_f
+    end
+
+    def type_name
+      'Chorus'
+    end
+  end
+
+  class Flanger < AudioEffect
+    attr_accessor :rate, :depth, :feedback, :delay
+
+    def initialize(rate: 0.5, depth: 1.0, feedback: 0.5, delay: 0.001, **kwargs)
+      super(**kwargs)
+      @rate = rate.to_f
+      @depth = depth.to_f
+      @feedback = feedback.to_f
+      @delay = delay.to_f
+    end
+
+    def type_name
+      'Flanger'
+    end
+  end
+
+  class Distortion < AudioEffect
+    attr_accessor :drive, :range, :blend
+
+    def initialize(drive: 0.5, range: 1000.0, blend: 0.5, **kwargs)
+      super(**kwargs)
+      @drive = drive.to_f
+      @range = range.to_f
+      @blend = blend.to_f
+    end
+
+    def type_name
+      'Distortion'
+    end
+  end
+
+  class AudioEffectChain
+    attr_reader :effects
+
+    def initialize
+      @effects = []
+    end
+
+    def add(effect)
+      @effects << effect
+      self
+    end
+
+    def remove(index)
+      @effects.delete_at(index)
+    end
+
+    def clear
+      @effects = []
+    end
+
+    def process(sample)
+      @effects.reduce(sample) do |s, effect|
+        effect.enabled ? apply_effect(effect, s) : s
+      end
+    end
+
+    def type_name
+      'AudioEffectChain'
+    end
+
+    private
+
+    def apply_effect(_effect, sample)
+      sample
+    end
+  end
+
+end

data/lib/bevy/camera.rb

@@ -0,0 +1,412 @@
+# frozen_string_literal: true
+
+module Bevy
+  class Camera2d
+    attr_reader :order, :clear_color, :viewport
+
+    def initialize(order: 0, clear_color: nil, viewport: nil)
+      @order = order
+      @clear_color = clear_color || Color.black
+      @viewport = viewport
+    end
+
+    def type_name
+      'Camera2d'
+    end
+
+    def with_order(order)
+      self.class.new(order: order, clear_color: @clear_color, viewport: @viewport)
+    end
+
+    def with_clear_color(clear_color)
+      self.class.new(order: @order, clear_color: clear_color, viewport: @viewport)
+    end
+
+    def with_viewport(viewport)
+      self.class.new(order: @order, clear_color: @clear_color, viewport: viewport)
+    end
+
+    def to_native
+      native = Component.new('Camera2d')
+      native['order'] = @order
+      native['clear_color_r'] = @clear_color.r
+      native['clear_color_g'] = @clear_color.g
+      native['clear_color_b'] = @clear_color.b
+      native['clear_color_a'] = @clear_color.a
+      if @viewport
+        native['viewport_x'] = @viewport.x
+        native['viewport_y'] = @viewport.y
+        native['viewport_width'] = @viewport.width
+        native['viewport_height'] = @viewport.height
+      end
+      native
+    end
+
+    def self.from_native(native)
+      clear_color = Color.new(
+        native['clear_color_r'] || 0.0,
+        native['clear_color_g'] || 0.0,
+        native['clear_color_b'] || 0.0,
+        native['clear_color_a'] || 1.0
+      )
+      viewport = nil
+      if native['viewport_width']
+        viewport = Viewport.new(
+          native['viewport_x'] || 0,
+          native['viewport_y'] || 0,
+          native['viewport_width'],
+          native['viewport_height']
+        )
+      end
+      new(order: native['order'] || 0, clear_color: clear_color, viewport: viewport)
+    end
+
+    def to_h
+      h = {
+        order: @order,
+        clear_color: @clear_color.to_a
+      }
+      h[:viewport] = @viewport.to_h if @viewport
+      h
+    end
+  end
+
+  class Camera3d
+    attr_reader :order, :clear_color, :fov, :near, :far, :viewport
+
+    def initialize(order: 0, clear_color: nil, fov: 45.0, near: 0.1, far: 1000.0, viewport: nil)
+      @order = order
+      @clear_color = clear_color || Color.black
+      @fov = fov
+      @near = near
+      @far = far
+      @viewport = viewport
+    end
+
+    def type_name
+      'Camera3d'
+    end
+
+    def with_order(order)
+      self.class.new(
+        order: order,
+        clear_color: @clear_color,
+        fov: @fov,
+        near: @near,
+        far: @far,
+        viewport: @viewport
+      )
+    end
+
+    def with_clear_color(clear_color)
+      self.class.new(
+        order: @order,
+        clear_color: clear_color,
+        fov: @fov,
+        near: @near,
+        far: @far,
+        viewport: @viewport
+      )
+    end
+
+    def with_fov(fov)
+      self.class.new(
+        order: @order,
+        clear_color: @clear_color,
+        fov: fov,
+        near: @near,
+        far: @far,
+        viewport: @viewport
+      )
+    end
+
+    def with_near(near)
+      self.class.new(
+        order: @order,
+        clear_color: @clear_color,
+        fov: @fov,
+        near: near,
+        far: @far,
+        viewport: @viewport
+      )
+    end
+
+    def with_far(far)
+      self.class.new(
+        order: @order,
+        clear_color: @clear_color,
+        fov: @fov,
+        near: @near,
+        far: far,
+        viewport: @viewport
+      )
+    end
+
+    def with_viewport(viewport)
+      self.class.new(
+        order: @order,
+        clear_color: @clear_color,
+        fov: @fov,
+        near: @near,
+        far: @far,
+        viewport: viewport
+      )
+    end
+
+    def to_native
+      native = Component.new('Camera3d')
+      native['order'] = @order
+      native['clear_color_r'] = @clear_color.r
+      native['clear_color_g'] = @clear_color.g
+      native['clear_color_b'] = @clear_color.b
+      native['clear_color_a'] = @clear_color.a
+      native['fov'] = @fov
+      native['near'] = @near
+      native['far'] = @far
+      if @viewport
+        native['viewport_x'] = @viewport.x
+        native['viewport_y'] = @viewport.y
+        native['viewport_width'] = @viewport.width
+        native['viewport_height'] = @viewport.height
+      end
+      native
+    end
+
+    def self.from_native(native)
+      clear_color = Color.new(
+        native['clear_color_r'] || 0.0,
+        native['clear_color_g'] || 0.0,
+        native['clear_color_b'] || 0.0,
+        native['clear_color_a'] || 1.0
+      )
+      viewport = nil
+      if native['viewport_width']
+        viewport = Viewport.new(
+          native['viewport_x'] || 0,
+          native['viewport_y'] || 0,
+          native['viewport_width'],
+          native['viewport_height']
+        )
+      end
+      new(
+        order: native['order'] || 0,
+        clear_color: clear_color,
+        fov: native['fov'] || 45.0,
+        near: native['near'] || 0.1,
+        far: native['far'] || 1000.0,
+        viewport: viewport
+      )
+    end
+
+    def to_h
+      h = {
+        order: @order,
+        clear_color: @clear_color.to_a,
+        fov: @fov,
+        near: @near,
+        far: @far
+      }
+      h[:viewport] = @viewport.to_h if @viewport
+      h
+    end
+  end
+
+  class Viewport
+    attr_reader :x, :y, :width, :height
+
+    def initialize(x, y, width, height)
+      @x = x
+      @y = y
+      @width = width
+      @height = height
+    end
+
+    def to_h
+      { x: @x, y: @y, width: @width, height: @height }
+    end
+  end
+
+  class SmoothFollow
+    attr_accessor :target, :offset, :smoothness, :enabled
+
+    def initialize(smoothness: 5.0, offset: nil, enabled: true)
+      @smoothness = smoothness
+      @offset = offset || Vec3.new(0.0, 0.0, 0.0)
+      @enabled = enabled
+      @target = nil
+    end
+
+    def type_name
+      'SmoothFollow'
+    end
+
+    def follow(target)
+      @target = target
+      self
+    end
+
+    def lerp_position(current, delta_time)
+      return current unless @target && @enabled
+
+      desired = Vec3.new(
+        @target.x + @offset.x,
+        @target.y + @offset.y,
+        @target.z + @offset.z
+      )
+      t = [@smoothness * delta_time, 1.0].min
+      Vec3.new(
+        current.x + (desired.x - current.x) * t,
+        current.y + (desired.y - current.y) * t,
+        current.z + (desired.z - current.z) * t
+      )
+    end
+
+    def to_native
+      native = Component.new('SmoothFollow')
+      native['smoothness'] = @smoothness
+      native['offset_x'] = @offset.x
+      native['offset_y'] = @offset.y
+      native['offset_z'] = @offset.z
+      native['enabled'] = @enabled
+      if @target
+        native['target_x'] = @target.x
+        native['target_y'] = @target.y
+        native['target_z'] = @target.z
+      end
+      native
+    end
+  end
+
+  class CameraShake
+    attr_accessor :intensity, :duration, :decay, :frequency
+    attr_reader :remaining_time
+
+    def initialize(frequency: 20.0, decay: 1.0)
+      @intensity = 0.0
+      @duration = 0.0
+      @decay = decay
+      @frequency = frequency
+      @remaining_time = 0.0
+      @time_elapsed = 0.0
+    end
+
+    def type_name
+      'CameraShake'
+    end
+
+    def trigger(intensity, duration, decay: nil)
+      @intensity = intensity
+      @duration = duration
+      @decay = decay if decay
+      @remaining_time = duration
+      @time_elapsed = 0.0
+    end
+
+    def update(delta_time)
+      return Vec2.new(0.0, 0.0) if @remaining_time <= 0.0
+
+      @remaining_time -= delta_time
+      @time_elapsed += delta_time
+
+      progress = 1.0 - (@remaining_time / @duration)
+      decay_factor = (1.0 - progress)**@decay
+      current_intensity = @intensity * decay_factor
+
+      angle = @time_elapsed * @frequency * Math::PI * 2
+      x = Math.sin(angle) * current_intensity
+      y = Math.cos(angle * 1.3) * current_intensity
+
+      Vec2.new(x, y)
+    end
+
+    def active?
+      @remaining_time > 0.0
+    end
+
+    def stop
+      @remaining_time = 0.0
+    end
+
+    def to_native
+      native = Component.new('CameraShake')
+      native['intensity'] = @intensity
+      native['duration'] = @duration
+      native['decay'] = @decay
+      native['frequency'] = @frequency
+      native['remaining_time'] = @remaining_time
+      native
+    end
+  end
+
+  class CameraBounds
+    attr_accessor :min_x, :min_y, :max_x, :max_y, :enabled
+
+    def initialize(min_x: nil, min_y: nil, max_x: nil, max_y: nil)
+      @min_x = min_x || -Float::INFINITY
+      @min_y = min_y || -Float::INFINITY
+      @max_x = max_x || Float::INFINITY
+      @max_y = max_y || Float::INFINITY
+      @enabled = min_x || min_y || max_x || max_y ? true : false
+    end
+
+    def type_name
+      'CameraBounds'
+    end
+
+    def clamp(position)
+      return position unless @enabled
+
+      Vec3.new(
+        [[position.x, @min_x].max, @max_x].min,
+        [[position.y, @min_y].max, @max_y].min,
+        position.z
+      )
+    end
+
+    def to_native
+      native = Component.new('CameraBounds')
+      native['min_x'] = @min_x
+      native['min_y'] = @min_y
+      native['max_x'] = @max_x
+      native['max_y'] = @max_y
+      native['enabled'] = @enabled
+      native
+    end
+  end
+
+  class CameraZoom
+    attr_accessor :current, :min, :max, :speed
+
+    def initialize(initial: 1.0, min: 0.1, max: 10.0, speed: 1.0)
+      @current = initial
+      @min = min
+      @max = max
+      @speed = speed
+    end
+
+    def type_name
+      'CameraZoom'
+    end
+
+    def zoom_in(amount = 0.1)
+      @current = [[@current - amount * @speed, @min].max, @max].min
+    end
+
+    def zoom_out(amount = 0.1)
+      @current = [[@current + amount * @speed, @min].max, @max].min
+    end
+
+    def set(value)
+      @current = [[value, @min].max, @max].min
+    end
+
+    def to_native
+      native = Component.new('CameraZoom')
+      native['current'] = @current
+      native['min'] = @min
+      native['max'] = @max
+      native['speed'] = @speed
+      native
+    end
+  end
+end

data/lib/bevy/component.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Bevy
+  class ComponentDSL
+    class << self
+      def attribute(name, type, default: nil)
+        @attributes ||= {}
+        @attributes[name] = { type: type, default: default }
+
+        define_method(name) do
+          @data[name]
+        end
+
+        define_method(:"#{name}=") do |value|
+          @data[name] = value
+        end
+      end
+
+      def attributes
+        @attributes ||= {}
+      end
+
+      def component_name
+        name.split('::').last
+      end
+
+      def inherited(subclass)
+        super
+        subclass.instance_variable_set(:@attributes, attributes.dup)
+      end
+    end
+
+    def initialize(**attrs)
+      @data = {}
+
+      self.class.attributes.each do |name, config|
+        default = config[:default]
+        default_value = default.respond_to?(:call) ? default.call : default
+        @data[name] = attrs.fetch(name, default_value)
+      end
+    end
+
+    def type_name
+      self.class.component_name
+    end
+
+    def to_native
+      native = Bevy::Component.new(type_name)
+      @data.each do |key, value|
+        next unless native_convertible?(value)
+
+        native[key.to_s] = value
+      end
+      native
+    end
+
+    def to_h
+      @data.dup
+    end
+
+    def [](name)
+      @data[name.to_sym]
+    end
+
+    def []=(name, value)
+      @data[name.to_sym] = value
+    end
+
+    def update_from_native(native)
+      @data.each_key do |key|
+        @data[key] = native[key.to_s]
+      end
+      self
+    end
+
+    private
+
+    def native_convertible?(value)
+      case value
+      when NilClass, TrueClass, FalseClass, Integer, Float, String, Symbol
+        true
+      when Array
+        value.all? { |v| native_convertible?(v) }
+      when Hash
+        value.all? { |k, v| native_convertible?(k) && native_convertible?(v) }
+      else
+        false
+      end
+    end
+  end
+end