jruby_art 0.9.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cb0e41ec051e87ef6d10ef371905c31970530399
-  data.tar.gz: bffce18e731c80959680481a1426aac30512fab3
+  metadata.gz: 8a6cd608ad55dfa06a0d23d02cd9f8d211f628e4
+  data.tar.gz: 6771e86dee627b35774d39b42fd4076681be5454
 SHA512:
-  metadata.gz: 438f7e83fac4d48ead0fae4e53fa2c8d9366eebc1f28fbcf34be225e59d3d5d48849ccf72ddc9b3c386ea511259325af7114057bf83144ebf9f3a808704a00c5
-  data.tar.gz: efb75f96fb117f63a215bd648a9b79ace3b7b8c96cf1addc3a6adff9a16940a7affe2473451a50db63371f6dfa63cc1a6454ef805efa89855f65304880f0069e
+  metadata.gz: bd5a6f88284c164a91e907cea990e42a572026a6cad2307687ef777450cbc7c895a5e7bdc8ce067508b6198af8d1f7d292d31eef07cb381671f6eb7aed06219f
+  data.tar.gz: 61ed2bd5e0881a7bcad3e179d3b36462d2d6a69e5944d543749afa01364433584b84ae9e69774fda56e5fe88defd5380c872eecc4e85ccbdfecbb11e35e0597e

data/lib/jruby_art/creators/creator.rb

@@ -8,7 +8,8 @@ def draw
 end
 
 def settings
-  size %s, %s, FX2D
+  size %s, %s
+  # pixel_density(2) # here for hi-dpi displays only
   # smooth # here
 end
 
@@ -41,7 +42,8 @@ class %s < Processing::App
   end
 
   def settings
-    size %s, %s, FX2D
+    size %s, %s
+    # pixel_density(2) # here for hi-dpi displays only
     # smooth # here
   end
 end

data/lib/jruby_art/version.rb

@@ -1,3 +1,3 @@
 module JRubyArt
-  VERSION = '0.9.0'
+  VERSION = '1.0.0'
 end

data/library/boids/boids.rb

@@ -1,120 +1,109 @@
 # Boids -- after Tom de Smedt.
 # See his Python version: http://nodebox.net/code/index.php/Boids
-# This is an example of how a pure-Ruby library can work.
-# -- omygawshkenas
-
+# This is an example of how a pure-Ruby library can work. Original for
+# ruby-processing Jeremy Ashkenas. Reworked, re-factored for JRubyArt 0.9+
+# by Martin Prout, features forwardable, keyword args, Vec3D and Vec2D.
 class Boid
-  attr_accessor :boids, :x, :y, :z, :vx, :vy, :vz, :is_perching, :perch_time
+  attr_accessor :boids, :pos, :vel, :is_perching, :perch_time
 
-  def initialize(boids, x, y, z)
+  def initialize(boids, pos)
     @boids, @flock = boids, boids
-    @x, @y, @z = x, y, z
-    @vx, @vy, @vz = 0.0, 0.0, 0.0
+    @pos = pos
+    @vel = Vec3D.new
     @is_perching = false
     @perch_time = 0.0
   end
 
-  def cohesion(d = 100.0)
+  def cohesion(d:)
     # Boids gravitate towards the center of the flock,
     # Which is the averaged position of the rest of the boids.
-    cvx, cvy, cvz = 0.0, 0.0, 0.0
-    boids.reject { |bd| bd.equal? self }.each do |boid|
-      cvx, cvy, cvz = cvx + boid.x, cvy + boid.y, cvz + boid.z
+    vect = Vec3D.new
+    @boids.each do |boid|
+      vect += boid.pos unless boid == self
     end
-    count = boids.length - 1.0
-    cvx, cvy, cvz = cvx / count, cvy / count, cvz / count
-    [(cvx - x) / d, (cvy - y) / d, (cvz - z) / d]
+    count = @boids.length - 1.0
+    vect /= count
+    (vect - pos) / d
   end
 
-  def separation(radius = 10.0)
+  def separation(radius:)
     # Boids don't like to cuddle.
-    svx, svy, svz = 0.0, 0.0, 0.0
-    boids.reject { |bd| bd.equal? self }.each do |boid|
-      dvx, dvy, dvz = x - boid.x, y - boid.y, z - boid.z
-      svx += dvx if dvx.abs < radius
-      svy += dvy if dvy.abs < radius
-      svz += dvz if dvz.abs < radius
+    vect = Vec3D.new
+    @boids.each do |boid|
+      if boid != self
+        dv = pos - boid.pos
+        vect += dv if dv.mag < radius
+      end
     end
-    [svx, svy, svz]
+    vect
   end
 
-  def alignment(d = 5.0)
+  def alignment(d:)
     # Boids like to fly at the speed of traffic.
-    avx, avy, avz = 0.0, 0.0, 0.0
-    boids.reject { |bd| bd.equal? self }.each do |boid|
-      avx, avy, avz = avx + boid.vx, avy + boid.vy, avz + boid.vz
+    vect = Vec3D.new
+    @boids.each do |boid|
+      vect += boid.vel if boid != self
     end
-    count = boids.length - 1.0
-    avx, avy, avz = avx / count, avy / count, avz / count
-    [(avx - vx) / d, (avy - vy) / d, (avz - vz) / d]
+    count = @boids.length - 1.0
+    vect /= count
+    (vect - vel) / d
   end
 
-  def limit(max = 30.0)
+  def limit(max:)
     # Tweet, Tweet! The boid police will bust you for breaking the speed limit.
-    most = [@vx.abs, @vy.abs, @vz.abs].max
+    most = [vel.x.abs, vel.y.abs, vel.z.abs].max
     return if most < max
     scale = max / most.to_f
-    @vx *= scale
-    @vy *= scale
-    @vz *= scale
+    @vel *= scale
   end
 
   def angle
-    a = (Math.atan(@vy / @vx) * (180.0 / Math::PI)) + 360.0
-    a += 180.0 if @vx < 0.0
-    a
+    Vec2D.new(vel.x, vel.y).heading
   end
 
-  def goal(gx, gy, gz, d = 50.0)
+  def goal(target, d = 50.0)
     # Them boids is hungry.
-    [(gx - x) / d, (gy - y) / d, (gz - z) / d]
+    (target - pos) / d
   end
 end
 
 require 'forwardable'
 
+# The Boids class
 class Boids
   include Enumerable
   extend Forwardable
   def_delegators(:@boids, :reject, :<<, :each, :shuffle!, :length, :next)
 
-  attr_accessor :boids, :x, :y, :w, :h,
-                :scattered, :has_goal, :flee
-
-  attr_reader :scatter, :scatter_time, :scatter_i,
-              :perch, :perch_y, :perch_t, :boids,
-              :goal_x, :goal_y, :goal_z
+  attr_reader :has_goal, :perch, :perch_tm, :perch_y
 
   def initialize
     @boids = []
   end
 
-  def self.flock(n, x, y, w, h)
-    Boids.new.setup(n, x, y, w, h)
+  def self.flock(n:, x:, y:, w:, h:)
+    flock = Boids.new.setup(n, x, y, w, h)
+    flock.goal(target: Vec3D.new(w / 2, h / 2, 0))
   end
 
   def setup(n, x, y, w, h)
     n.times do
       dx, dy = rand(w), rand(h)
       z = rand(200.0)
-      self << Boid.new(self, x + dx, y + dy, z)
+      self << Boid.new(self, Vec3D.new(x + dx, y + dy, z))
     end
     @x, @y, @w, @h = x, y, w, h
-    init
-    self
-  end
-
-  def init
     @scattered = false
     @scatter = 0.005
     @scatter_time = 50.0
     @scatter_i = 0.0
     @perch = 1.0 # Lower this number to divebomb.
     @perch_y = h
-    @perch_t = -> { rand(25..75.0) }
+    @perch_tm = -> { 25.0 + rand(50.0) }
     @has_goal = false
     @flee = false
-    @goal_x = @goal_y = @goal_z = 0.0
+    @goal = Vec3D.new
+    self
   end
 
   def scatter(chance = 0.005, frames = 50.0)
@@ -127,19 +116,20 @@ class Boids
   end
 
   def perch(ground = nil, chance = 1.0, frames = nil)
-    frames ||= -> { rand(25..75.0) }
-    ground ||= h
-    @perch, @perch_y, @perch_t = chance, ground, frames
+    @perch_tm = frames.nil? ? -> { 25.0 + rand(50.0) } : frames
+    @perch_y = ground.nil? ? @h : ground
+    @perch = chance
   end
 
   def no_perch
     @perch = 0.0
   end
 
-  def goal(gx, gy, gz, flee = false)
+  def goal(target:, flee: false)
     @has_goal = true
     @flee = flee
-    @goal_x, @goal_y, @goal_z = gx, gy, gz
+    @goal = target
+    self
   end
 
   def no_goal
@@ -148,37 +138,34 @@ class Boids
 
   def constrain
     # Put them boids in a cage.
-    dx, dy = w * 0.1, h * 0.1
+    dx, dy = @w * 0.1, @h * 0.1
     each do |b|
-      b.vx += rand(dx) if b.x < x - dx
-      b.vx += rand(dy) if b.y < y - dy
-      b.vx -= rand(dx) if b.x > x + w + dx
-      b.vy -= rand(dy) if b.y > y + h + dy
-      b.vz += 10.0 if b.z < 0.0
-      b.vz -= 10.0 if b.z > 100.0
-      next unless b.y > @perch_y && rand < @perch
-      b.y = @perch_y
-      b.vy = -(b.vy.abs) * 0.2
+      b.vel.x += rand(dx) if b.pos.x < @x - dx
+      b.vel.x += rand(dy) if b.pos.y < @y - dy
+      b.vel.x -= rand(dx) if b.pos.x > @x + @w + dx
+      b.vel.y -= rand(dy) if b.pos.y > @y + @h + dy
+      b.vel.z += 10.0 if b.pos.z < 0.0
+      b.vel.z -= 10.0 if b.pos.z > 100.0
+      next unless b.pos.y > perch_y && rand < perch
+      b.pos.y = perch_y
+      b.vel.y = -(b.vel.y.abs) * 0.2
       b.is_perching = true
-      @perch_t.respond_to?(:call) ? b.perch_time = @perch_t.call : b.perch_time = @perch_t
+      b.perch_time = perch_tm.respond_to?(:call) ? perch_tm.call : perch_tm
     end
   end
 
-  def update(opts = {}) # Just flutter, little boids ... just flutter away.
-    options = {
-      shuffled: true,     #  Shuffling keeps things flowing smooth.
-      cohesion: 100.0,
-      separation: 10.0,
-      alignment: 5.0,
-      goal: 20.0,
-      limit: 30.0
-    }
-    options.merge! opts
-    shuffle! if options[:shuffled]
-    m1 = 1.0   # cohesion
-    m2 = 1.0   # separation
-    m3 = 1.0   # alignment
-    m4 = 1.0   # goal
+  def update(goal: 20.0, limit: 30.0, **args)
+    shuffled = args.fetch(:shuffled, true)
+    cohesion = args.fetch(:cohesion, 100)
+    separation = args.fetch(:separation, 10)
+    alignment = args.fetch(:alignment, 5.0)
+    # Just flutter, little boids ... just flutter away.
+    # Shuffling keeps things flowing smooth.
+    shuffle! if shuffled
+    m1 = 1.0 # cohesion
+    m2 = 1.0 # separation
+    m3 = 1.0 # alignment
+    m4 = 1.0 # goal
     @scattered = true if !(@scattered) && rand < @scatter
     if @scattered
       m1 = -m1
@@ -189,7 +176,7 @@ class Boids
       @scattered = false
       @scatter_i = 0.0
     end
-    m4 = 0.0 unless @has_goal
+    m4 = 0.0 unless has_goal
     m4 = -m4 if @flee
     each do |b|
       if b.is_perching
@@ -200,17 +187,14 @@ class Boids
           b.is_perching = false
         end
       end
-      vx1, vy1, vz1 = *b.cohesion(options[:cohesion])
-      vx2, vy2, vz2 = *b.separation(options[:separation])
-      vx3, vy3, vz3 = *b.alignment(options[:alignment])
-      vx4, vy4, vz4 = b.goal(@goal_x, @goal_y, @goal_z, options[:goal])
-      b.vx += m1 * vx1 + m2 * vx2 + m3 * vx3 + m4 * vx4
-      b.vy += m1 * vy1 + m2 * vy2 + m3 * vy3 + m4 * vy4
-      b.vz += m1 * vz1 + m2 * vz2 + m3 * vz3 + m4 * vz4
-      b.limit(options[:limit])
-      b.x += b.vx
-      b.y += b.vy
-      b.z += b.vz
+      v1 = b.cohesion(d: cohesion)
+      v2 = b.separation(radius: separation)
+      v3 = b.alignment(d: alignment)
+      v4 = b.goal(@goal, goal)
+      # NB: vector must precede scalar in '*' operation below
+      b.vel += (v1 * m1 + v2 * m2 + v3 * m3 + v4 * m4)
+      b.limit(max: limit)
+      b.pos += b.vel
     end
     constrain
   end

data/vendors/Rakefile

@@ -8,8 +8,8 @@ WARNING = <<-EOS
       
 EOS
 
-JRUBYC_VERSION     = '9.0.1.0'
-EXAMPLES           = '0.8'
+JRUBYC_VERSION     = '9.0.3.0'
+EXAMPLES           = '1.0'
 HOME_DIR = ENV['HOME']
 MAC_OR_LINUX = /linux|mac|darwin/ =~ RbConfig::CONFIG['host_os'] 
 
@@ -27,7 +27,7 @@ file "jruby-complete-#{JRUBYC_VERSION}.jar" do
   rescue
     warn(WARNING)
   end
-  check_sha1("jruby-complete-#{JRUBYC_VERSION}.jar", "523f0054455d85cdfc53af6eb8e925228feb9777")
+  check_sha1("jruby-complete-#{JRUBYC_VERSION}.jar", "d57e15c1bf3068cecaf0f2dab95affa4072114f6")
 end
 
 directory "../lib/ruby"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jruby_art
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Jeremy Ashkenas
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-09-30 00:00:00.000000000 Z
+date: 2015-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -70,7 +70,7 @@ dependencies:
         version: '5.8'
 description: |2
     JRubyArt is a ruby wrapper for the processing art framework.
-    The current version supports processing-3.0b7, and uses jruby-9.0.1.0
+    The current version supports processing-3.0, and uses jruby-9.0.3.0
     as the glue between ruby and java. You can use both processing libraries and ruby
     gems in your sketches. Features create/run/watch/live modes. The "watch" mode,
     provides a nice REPL-ish way to work on your processing sketches. Includes:-
@@ -128,7 +128,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - A decent graphics card
 - java runtime >= 1.8+
-- processing = 3.0b7+
+- processing = 3.0+
 rubyforge_project:
 rubygems_version: 2.4.8
 signing_key: