rubysketch 0.9.5 → 0.11.0

data/lib/rubysketch/constraint.rb

@@ -0,0 +1,422 @@
+module RubySketch
+
+
+  # Constrains the motion of sprites.
+  # Constraints are created with Sprite#snap, #link, #wheel and #chase
+  # (or the same verbs on Sprite#pin), not with new.
+  #
+  class Constraint
+
+    include Xot::Setter
+
+    # @private
+    def initialize(constraint)
+      @constraint__ = constraint
+    end
+
+    # Removes the constraint permanently.
+    #
+    # @return [Constraint] self
+    #
+    def remove()
+      @constraint__.remove
+      self
+    end
+
+    # Sets the spring stiffness in hertz.
+    #
+    # @param [Numeric, nil] hertz stiffness, or nil to make it rigid
+    #
+    # @return [Numeric, nil] hertz
+    #
+    def spring=(hertz)
+      @constraint__.spring = hertz
+    end
+
+    # Returns the spring stiffness in hertz.
+    #
+    # @return [Numeric, nil] hertz, or nil if the constraint is rigid
+    #
+    def spring()
+      @constraint__.spring
+    end
+
+    # Sets the spring damping ratio.
+    #
+    # @param [Numeric] ratio 0 (no damping) to 1 (critical damping)
+    #
+    # @return [Numeric] damping ratio
+    #
+    def damping=(ratio)
+      @constraint__.damping = ratio
+    end
+
+    # Returns the spring damping ratio.
+    #
+    # @return [Numeric] damping ratio
+    #
+    def damping()
+      @constraint__.damping
+    end
+
+    # Sets whether the constrained sprites collide with each other.
+    #
+    # @param [Boolean] bool collide or not
+    #
+    # @return [Boolean] collide or not
+    #
+    def collide=(bool)
+      @constraint__.collide = bool
+    end
+
+    # Returns whether the constrained sprites collide with each other.
+    #
+    # @return [Boolean] collide or not
+    #
+    def collide?()
+      @constraint__.collide?
+    end
+
+    # Sets the maximum force (or torque) that drives the constraint.
+    #
+    # @param [Numeric, nil] force
+    #  maximum force, or nil for the default strength.
+    #  0 makes the drive powerless
+    #
+    # @return [Numeric, nil] force
+    #
+    def force=(force)
+      @constraint__.force = force
+    end
+
+    # Returns the maximum force that drives the constraint.
+    #
+    # @return [Numeric, nil] force, or nil for the default strength
+    #
+    def force()
+      @constraint__.force
+    end
+
+    universal_accessor :spring, :damping, :force, collide: {reader: :collide?}
+
+    # Returns whether the constraint is active in a physics world.
+    #
+    # @return [Boolean] active or not
+    #
+    def active?()
+      @constraint__.active?
+    end
+
+    # Returns whether the constraint was removed.
+    #
+    # @return [Boolean] removed or not
+    #
+    def removed?()
+      @constraint__.removed?
+    end
+
+    # Returns the sprites the constraint is fastened to.
+    #
+    # @return [Array<Sprite, nil>] nil for a world anchor
+    #
+    def sprites()
+      @sprites__ ||= @constraint__.views.map {_1&.sprite}.freeze
+    end
+
+    # @private
+    def ==(o)
+      o.is_a?(Constraint) && @constraint__ == o.getInternal__
+    end
+
+    alias eql? ==
+
+    # @private
+    def hash()
+      @constraint__.hash
+    end
+
+    # @private
+    def getInternal__()
+      @constraint__
+    end
+
+    # @private
+    def self.wrap__(constraint)
+      klass =
+        case constraint
+        when Reflex::SnapConstraint  then SnapConstraint
+        when Reflex::LinkConstraint  then LinkConstraint
+        when Reflex::WheelConstraint then WheelConstraint
+        when Reflex::ChaseConstraint then ChaseConstraint
+        else raise ArgumentError, "unknown constraint type: #{constraint.class}"
+        end
+      klass.new constraint
+    end
+
+    private
+
+    def getContext__()
+      sprites.first&.getContext__ || Processing.context
+    end
+
+    def toDegrees__(angle)
+      getContext__.toDegrees__ angle
+    end
+
+    def fromDegrees__(degrees)
+      getContext__.fromDegrees__ degrees
+    end
+
+  end# Constraint
+
+
+  # Snaps two points together like a hinge.
+  #
+  class SnapConstraint < Constraint
+
+    # Sets the range of the relative rotation angle.
+    #
+    # @param [Range, Numeric, nil] angle
+    #  radians or degrees depending on angleMode().
+    #  nil rotates freely, 0 fixes the rotation
+    #
+    # @return [Range, Numeric, nil] angle
+    #
+    def angle=(angle)
+      @constraint__.angle =
+        case angle
+        when Range   then Range.new toDegrees__(angle.begin), toDegrees__(angle.end)
+        when Numeric then toDegrees__ angle
+        else              angle
+        end
+    end
+
+    # Returns the range of the relative rotation angle.
+    #
+    # @return [Range, nil] radians or degrees depending on angleMode()
+    #
+    def angle()
+      angle = @constraint__.angle
+      angle ? Range.new(fromDegrees__(angle.begin), fromDegrees__(angle.end)) : nil
+    end
+
+    # Sets the motor speed that drives the relative rotation.
+    #
+    # @param [Numeric, nil] speed
+    #  angular velocity per second, radians or degrees depending on
+    #  angleMode(). nil stops the motor
+    #
+    # @return [Numeric, nil] speed
+    #
+    def motor=(speed)
+      @constraint__.motor = speed && toDegrees__(speed)
+    end
+
+    # Returns the motor speed.
+    #
+    # @return [Numeric, nil] angular velocity per second
+    #
+    def motor()
+      speed = @constraint__.motor
+      speed && fromDegrees__(speed)
+    end
+
+    universal_accessor :angle, :motor
+
+  end# SnapConstraint
+
+
+  # Keeps two points apart at a distance, or slides them along an axis
+  # like a rail.
+  #
+  class LinkConstraint < Constraint
+
+    # Sets the axis to slide along.
+    # With an axis, the separation is measured along it instead of
+    # radially, and the relative rotation is locked like a rail.
+    #
+    # @param [Vector, Array<Numeric>, nil] axis
+    #  direction in the target local space, or nil to link radially
+    #
+    # @return [Vector, Array<Numeric>, nil] axis
+    #
+    def axis=(axis)
+      @constraint__.axis = RubySketch.unwrap__ axis
+    end
+
+    # Returns the axis to slide along.
+    #
+    # @return [Vector, nil] axis, or nil for a radial link
+    #
+    def axis()
+      @constraint__.axis&.toVector
+    end
+
+    # Sets the distance to keep.
+    #
+    # @param [Numeric] distance distance in pixels
+    #
+    # @return [Numeric] distance
+    #
+    def distance=(distance)
+      @constraint__.distance = distance
+    end
+
+    # Returns the distance to keep.
+    #
+    # @return [Numeric] distance in pixels
+    #
+    def distance()
+      @constraint__.distance
+    end
+
+    # Returns the current distance between the two points.
+    #
+    # @return [Numeric] distance in pixels, or 0 if not active in a world
+    #
+    def currentDistance()
+      @constraint__.current_distance
+    end
+
+    # Sets the range of the separation.
+    #
+    # @param [Range, Numeric, nil] range
+    #  distance range like a rope, or the translation range along the axis
+    #
+    # @return [Range, Numeric, nil] range
+    #
+    def range=(range)
+      @constraint__.range = range
+    end
+
+    # Returns the range of the separation.
+    #
+    # @return [Range, nil] separation range
+    #
+    def range()
+      @constraint__.range
+    end
+
+    # Sets the motor speed that drives the separation.
+    #
+    # @param [Numeric, nil] speed speed in pixels per second, or nil to stop
+    #
+    # @return [Numeric, nil] speed
+    #
+    def motor=(speed)
+      @constraint__.motor = speed
+    end
+
+    # Returns the motor speed.
+    #
+    # @return [Numeric, nil] speed in pixels per second
+    #
+    def motor()
+      @constraint__.motor
+    end
+
+    universal_accessor :axis, :distance, :range, :motor
+
+    alias dist= distance=
+    alias dist  distance
+
+  end# LinkConstraint
+
+
+  # Rides on the target like a wheel: slides along an axis for the
+  # suspension while spinning freely.
+  #
+  class WheelConstraint < Constraint
+
+    # Sets the axis to slide along for the suspension.
+    #
+    # @param [Vector, Array<Numeric>] axis direction in the target local space
+    #
+    # @return [Vector, Array<Numeric>] axis
+    #
+    def axis=(axis)
+      @constraint__.axis = RubySketch.unwrap__ axis
+    end
+
+    # Returns the axis to slide along.
+    #
+    # @return [Vector] axis
+    #
+    def axis()
+      @constraint__.axis&.toVector
+    end
+
+    # Sets the range of the translation along the axis.
+    #
+    # @param [Range, Numeric, nil] range translation range in pixels
+    #
+    # @return [Range, Numeric, nil] range
+    #
+    def range=(range)
+      @constraint__.range = range
+    end
+
+    # Returns the range of the translation along the axis.
+    #
+    # @return [Range, nil] translation range
+    #
+    def range()
+      @constraint__.range
+    end
+
+    # Sets the motor speed that spins the wheel.
+    #
+    # @param [Numeric, nil] speed
+    #  angular velocity per second, radians or degrees depending on
+    #  angleMode(). nil stops the motor
+    #
+    # @return [Numeric, nil] speed
+    #
+    def motor=(speed)
+      @constraint__.motor = speed && toDegrees__(speed)
+    end
+
+    # Returns the motor speed.
+    #
+    # @return [Numeric, nil] angular velocity per second
+    #
+    def motor()
+      speed = @constraint__.motor
+      speed && fromDegrees__(speed)
+    end
+
+    universal_accessor :axis, :range, :motor
+
+  end# WheelConstraint
+
+
+  # Moves a point toward the target every frame.
+  #
+  class ChaseConstraint < Constraint
+
+    # Sets the target to chase.
+    #
+    # @param [Sprite, Pin, Vector, Array<Numeric>, nil] target
+    #  the center of a sprite, a pin, or a point in the world.
+    #  nil chases nothing
+    #
+    # @return [Sprite, Pin, Vector, Array<Numeric>, nil] target
+    #
+    def target=(target)
+      @constraint__.target = RubySketch.unwrap__ target
+    end
+
+    # Returns the target to chase.
+    #
+    # @return [Pin] the target pin
+    #
+    def target()
+      Pin.new nil, pin__: @constraint__.target
+    end
+
+    universal_accessor :target
+
+  end# ChaseConstraint
+
+
+end# RubySketch

data/lib/rubysketch/context.rb

@@ -14,15 +14,15 @@ module RubySketch
     # @private
     def initialize(window)
       super
-      @window__          = window
-      @timers__          = {}
-      @firingTimers__    = {}
-      @nextTimerID__     = 0
-      @noteNumber__      = 69
-      @noteFrequency__   = 440
-      @noteVelocity__    = 1
-      @controllerIndex__ = 0
-      @controllerValue__ = 0
+      @window__           = window
+      @timers__           = {}
+      @firingTimers__     = {}
+      @nextTimerID__      = 0
+      @noteNumber__       = 69
+      @noteFrequency__    = 440
+      @noteVelocity__     = 1
+      @controllerNumber__ = 0
+      @controllerValue__  = 0
 
       @world__ = createWorld
 
@@ -33,14 +33,14 @@ module RubySketch
       }
 
       updateControllerStates = -> event {
-        @controllerIndex__ = event.controller
-        @controllerValue__ = event.value
+        @controllerNumber__ = event.controller
+        @controllerValue__  = event.value
       }
 
       @window__.update_window = proc do
         fireTimers__
         Beeps.process_streams!
-        Reflex.process_events!
+        Reflex.process_events!# TODO: delete this
       end
 
       @window__.note_on  = proc do |e|
@@ -265,29 +265,29 @@ module RubySketch
     # @return [Sprite] the new sprite object
     #
     def createSprite(*args, **kwargs)
-      @world__.createSprite(*args, context: self, **kwargs)
+      @world__.createSprite(*args, **kwargs)
     end
 
     # Adds sprite to the physics engine.
     #
-    # @param [Array]  array user array to store the sprite
     # @param [Sprite] sprite sprite object
+    # @param [Array]  to     user array to store the sprite
     #
     # @return [Sprite] the added sprite
     #
-    def addSprite(array = nil, sprite)
-      @world__.addSprite array, sprite
+    def addSprite(...)
+      @world__.addSprite(...)
     end
 
     # Removes sprite from the physics engine.
     #
-    # @param [Array]  array user array to remove the sprite
     # @param [Sprite] sprite sprite object
+    # @param [Array]  from   user array to remove the sprite
     #
     # @return [Sprite] the removed sprite
     #
-    def removeSprite(array = nil, sprite)
-      @world__.removeSprite array, sprite
+    def removeSprite(...)
+      @world__.removeSprite(...)
     end
 
     alias drawSprite sprite
@@ -307,7 +307,11 @@ module RubySketch
     # @return [SpriteWorld] first added world
     #
     def addWorld(*worlds)
-      worlds.each {@window__.add_overlay _1.getInternal__}
+      raise ArgumentError if worlds.any? {_1.getContext__}
+      worlds.each do |world|
+        @window__.add_overlay world.getInternal__
+        world.attached__
+      end
       worlds.first
     end
 
@@ -318,7 +322,11 @@ module RubySketch
     # @return [SpriteWorld] first removed world
     #
     def removeWorld(*worlds)
-      worlds.each {@window__.remove_overlay _1.getInternal__}
+      raise ArgumentError if worlds.any? {_1.getContext__ != self}
+      worlds.each do |world|
+        @window__.remove_overlay world.getInternal__
+        world.detached__
+      end
       worlds.first
     end
 
@@ -356,12 +364,12 @@ module RubySketch
       @noteVelocity__
     end
 
-    # Returns the last controller index that was changed.
+    # Returns the last controller number that was changed.
     #
-    # @return [Numeric] last controller index
+    # @return [Numeric] last controller number
     #
-    def controllerIndex()
-      @controllerIndex__
+    def controllerNumber()
+      @controllerNumber__
     end
 
     # Returns the last controller value that was changed.

data/lib/rubysketch/extension.rb

@@ -7,7 +7,7 @@ module RubySketch
     module_function
 
     def name(downcase = false)
-      super().split('::')[-2].then {|s|
+      super().split('::')[..-2].join.then {|s|
         downcase ? s.downcase : s
       }
     end

data/lib/rubysketch/helper.rb

@@ -4,3 +4,13 @@ class Rays::Point
     Processing::Vector.new x, y, z
   end
 end
+
+
+module RubySketch
+
+  # @private
+  def self.unwrap__(arg)
+    arg.respond_to?(:getInternal__) ? arg.getInternal__ : arg
+  end
+
+end# RubySketch

data/lib/rubysketch/pin.rb

@@ -0,0 +1,108 @@
+module RubySketch
+
+
+  # A pin fastened at a point on a sprite.
+  # Creating a constraint between sprites starts from a pin.
+  #
+  class Pin
+
+    # @private
+    def initialize(sprite, x = nil, y = nil, pin__: nil)
+      if pin__
+        @sprite__ = pin__.view&.sprite
+        @pin__    = pin__
+      else
+        @sprite__ = sprite
+        @pin__    = x ? sprite.getInternal__.pin(x, y) : sprite.getInternal__.pin
+      end
+    end
+
+    # Creates a constraint that makes the pin and the target point coincide.
+    #
+    # @param [Sprite, Pin, Vector, Array<Numeric>, nil] target
+    #  the center of a sprite, a pin, or a point in the world.
+    #  snaps to the world when target is omitted
+    #
+    # @return [SnapConstraint] a new constraint
+    #
+    def snap(*args, **options, &block)
+      create__ SnapConstraint, @pin__.snap(*unwrap__(args)), options, block
+    end
+
+    # Creates a constraint that keeps the distance to the target point.
+    #
+    # @param [Sprite, Pin, Vector, Array<Numeric>, nil] target
+    #  the center of a sprite, a pin, or a point in the world.
+    #  links to the world when target is omitted
+    #
+    # @return [LinkConstraint] a new constraint
+    #
+    def link(*args, **options, &block)
+      create__ LinkConstraint, @pin__.link(*unwrap__(args)), options, block
+    end
+
+    # Creates a constraint that makes the pin ride on the target like a
+    # wheel: it slides along an axis for the suspension and spins freely.
+    #
+    # @param [Sprite, Pin, Vector, Array<Numeric>, nil] target
+    #  the center of a sprite, a pin, or a point in the world.
+    #  rides on the world when target is omitted
+    #
+    # @return [WheelConstraint] a new constraint
+    #
+    def wheel(*args, **options, &block)
+      create__ WheelConstraint, @pin__.wheel(*unwrap__(args)), options, block
+    end
+
+    # Creates a constraint that moves the pin toward the target every frame.
+    #
+    # @param [Sprite, Pin, Vector, Array<Numeric>, nil] target
+    #  the center of a sprite, a pin, or a point in the world.
+    #  chases nothing when target is omitted
+    #
+    # @return [ChaseConstraint] a new constraint
+    #
+    def chase(*args, **options, &block)
+      create__ ChaseConstraint, @pin__.chase(*unwrap__(args)), options, block
+    end
+
+    # Returns the sprite the pin is fastened to.
+    #
+    # @return [Sprite, nil] nil for a pin in the world
+    #
+    def sprite()
+      @sprite__
+    end
+
+    # Returns the position of the pin.
+    #
+    # @return [Vector, nil] sprite-local position, or nil for the center
+    #
+    def position()
+      @pin__.position&.toVector
+    end
+
+    alias pos position
+
+    # @private
+    def getInternal__()
+      @pin__
+    end
+
+    private
+
+    def create__(klass, constraint, options, block)
+      klass.new(constraint).tap do |c|
+        c.set options unless options.empty?
+        Xot::BlockUtil.instance_eval_or_block_call c, &block if block
+      end
+    end
+
+    def unwrap__(args)
+      args.map {|arg| RubySketch.unwrap__ arg}
+    end
+
+  end# Pin
+
+
+end# RubySketch

data/lib/rubysketch/shape.rb

@@ -83,7 +83,7 @@ module RubySketch
 
     # @deprecated Use {#contactEnd} instead.
     def contact_end(&block)
-      warn "Shape#contact_end is deprecated, use #contactEnd instead", uniq: true
+      Xot.warn "Shape#contact_end is deprecated, use #contactEnd instead", uniq: true
       contactEnd(&block)
     end