picrate 0.0.2-java

data/lib/picrate/runner.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: false
+require 'optparse'
+require_relative 'version'
+
+module Processing
+  # Utility class to handle the different commands that the 'picrate' offers
+  class Runner
+    attr_reader :options, :argc, :filename
+
+    def initialize
+      @options = {}
+    end
+
+    # Start running a picrate command from the passed-in arguments
+    def self.execute
+      runner = new
+      runner.parse_options(ARGV)
+      runner.execute!
+    end
+
+    # Dispatch central.
+    def execute!
+      show_help if options.empty?
+      show_version if options[:version]
+      create if options[:create]
+      install(filename) if options[:install]
+    end
+
+    # Parse the command-line options. Keep it simple.
+    def parse_options(args)
+      opt_parser = OptionParser.new do |opts|
+        # Set a banner, displayed at the top
+        # of the help screen.
+        opts.banner = 'Usage: picrate [options] [<sketch.rb>]'
+
+        # Define the options, and what they do
+        options[:version] = false
+        opts.on('-v', '--version', 'Processing Version') do
+          options[:version] = true
+        end
+
+        options[:install] = false
+        message = '<Samples><GLVideo><Video><Sound> Install samples or library'
+        opts.on('-i', '--install', message) do
+          options[:install] = true
+        end
+
+        options[:create] = false
+        opts.on('-c', '--create', 'Create new sketch outline') do
+          options[:create] = true
+        end
+
+        # This displays the help screen, all programs are
+        # assumed to have this option.
+        opts.on('-h', '--help', 'Display this screen') do
+          puts opts
+          exit
+        end
+      end
+      @argc = opt_parser.parse(args)
+      @filename = argc.shift
+    end
+
+    def create
+      require_relative 'creators/sketch_writer'
+      SketchWriter.new(File.basename(filename, '.rb'), argc).write
+    end
+
+    def show_version
+      v_format = "Processing version %s\nJRuby version %s"
+      puts format(v_format, Processing::VERSION, JRUBY_VERSION)
+    end
+
+    def install(library)
+      choice = library.downcase
+      valid = Regexp.union('samples', 'sound', 'video', 'glvideo')
+      return warn format('No installer for %s', choice) unless valid =~ choice
+      system "cd #{PICRATE_ROOT}/vendors && rake download_and_copy_#{choice}"
+    end
+  end # class Runner
+end # module Processing

data/lib/picrate/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module PiCrate
+  VERSION = '0.0.2'.freeze
+end

data/library/boids/boids.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+# 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. 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_reader :boids
+  attr_accessor :vel, :pos, :is_perching, :perch_time
+  def initialize(boids, pos)
+    @boids, @flock = boids, boids
+    @pos = pos
+    @vel = Vec3D.new
+    @is_perching = false
+    @perch_time = 0.0
+  end
+
+  def cohesion(d:)
+    # Boids gravitate towards the center of the flock,
+    # Which is the averaged position of the rest of the boids.
+    vect = Vec3D.new
+    @boids.each do |boid|
+      vect += boid.pos unless boid == self
+    end
+    count = @boids.length - 1.0
+    vect /= count
+    (vect - pos) / d
+  end
+
+  def separation(radius:)
+    # Boids don't like to cuddle.
+    vect = Vec3D.new
+    @boids.each do |boid|
+      if boid != self
+        dv = pos - boid.pos
+        vect += dv if dv.mag < radius
+      end
+    end
+    vect
+  end
+
+  def alignment(d:)
+    # Boids like to fly at the speed of traffic.
+    vect = Vec3D.new
+    @boids.each do |boid|
+      vect += boid.vel if boid != self
+    end
+    count = @boids.length - 1.0
+    vect /= count
+    (vect - vel) / d
+  end
+
+  def limit(max:)
+    # Tweet, Tweet! The boid police will bust you for breaking the speed limit.
+    most = [vel.x.abs, vel.y.abs, vel.z.abs].max
+    return if most < max
+    scale = max / most.to_f
+    @vel *= scale
+  end
+
+  def angle
+    Vec2D.new(vel.x, vel.y).heading
+  end
+
+  def goal(target, d = 50.0)
+    # Them boids is hungry.
+    (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_reader :has_goal, :perch, :perch_tm, :perch_y
+
+  def initialize
+    @boids = []
+  end
+
+  def self.flock(n:, x:, y:, w:, h:)
+    flock = Boids.new.setup(n, x, y, w, h)
+    flock.reset_goal(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, Vec3D.new(x + dx, y + dy, z))
+    end
+    @x, @y, @w, @h = x, y, w, h
+    @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_tm = -> { 25.0 + rand(50.0) }
+    @has_goal = false
+    @flee = false
+    @goal = Vec3D.new
+    self
+  end
+
+  def scatter(chance = 0.005, frames = 50.0)
+    @scatter = chance
+    @scatter_time = frames
+  end
+
+  def no_scatter
+    @scatter = 0.0
+  end
+
+  def perch(ground = nil, chance = 1.0, frames = nil)
+    @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 reset_goal(target)
+    @has_goal = true
+    @flee = false
+    @goal = target
+    self
+  end
+
+  def goal(target:, flee:)
+    @has_goal = true
+    @flee = flee
+    @goal = target
+    self
+  end
+
+  def no_goal
+    @has_goal = false
+  end
+
+  def constrain
+    # Put them boids in a cage.
+    dx, dy = @w * 0.1, @h * 0.1
+    each do |b|
+      b.vel.x += rand(dx) if b.pos.x < @x - dx
+      b.vel.y += 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
+      b.perch_time = perch_tm.respond_to?(:call) ? perch_tm.call : perch_tm
+    end
+  end
+
+  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
+      m3 *= 0.25
+      @scatter_i += 1.0
+    end
+    if @scatter_i >= @scatter_time
+      @scattered = false
+      @scatter_i = 0.0
+    end
+    m4 = 0.0 unless has_goal
+    m4 = -m4 if @flee
+    each do |b|
+      if b.is_perching
+        if b.perch_time > 0.0
+          b.perch_time -= 1.0
+          next
+        else
+          b.is_perching = false
+        end
+      end
+      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
+end

data/library/chooser/chooser.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+# Usage:
+# load_library :chooser
+# 
+# def setup
+  # java_signature 'void selectInput(String, String)'
+  # selectInput('Select a file to process:', 'fileSelected')
+# end
+# 
+# def fileSelected(selection)
+  # if selection.nil?
+    # puts 'Window was closed or the user hit cancel.'
+  # else
+    # puts format('User selected %s', selection.get_absolute_path)
+  # end
+# end
+class Processing::App
+  include Java::MonkstoneFilechooser::Chooser
+end

data/library/control_panel/control_panel.rb

@@ -0,0 +1,182 @@
+# Here's a little library for quickly hooking up controls to sketches.
+# For messing with the parameters and such.
+# These controls will set instance variables on the sketches.
+# You can make sliders, checkboxes, buttons, and drop-down menus.
+# Optionally pass range and a default value to sliders.
+module ControlPanel
+  def self.app_value(name, val)
+    Processing.app.instance_variable_set("@#{name}", val)
+  end
+
+  # class used to create slider elements for control_panel
+  class Slider < javax.swing.JSlider
+    def initialize(control_panel, name, range, initial, proc = nil)
+      min = range.begin * 100
+      mx = range.end
+      mx = range.max if range.exclude_end? && range.begin.respond_to?(:succ)
+      max = mx * 100
+      val = range.cover?(initial) ? initial * 100 : (range.first + range.last) * 50
+      super(min, max, val)
+      set_minor_tick_spacing((max - min).abs / 10)
+      set_paint_ticks true
+      # paint_labels = true
+      set_preferred_size(java.awt.Dimension.new(190, 30))
+      label = control_panel.add_element(self, name)
+      add_change_listener do
+        update_label(label, name, value)
+        ControlPanel.app_value(name, value)
+        proc.call(value) if proc
+      end
+      ControlPanel.app_value(name, val)
+    end
+
+    def value
+      get_value / 100.0
+    end
+
+    def update_label(label, name, value)
+      value = value.to_s
+      value << '0' if value.length < 4
+      label.set_text "<html><br><b>#{name}: #{value}</b></html>"
+    end
+  end
+
+  # class used to combo_box menu elements for control_panel
+  class Menu < javax.swing.JComboBox
+    def initialize(control_panel, name, elements, initial_value, proc = nil)
+      super(elements.to_java(:String))
+      set_preferred_size(java.awt.Dimension.new(190, 30))
+      control_panel.add_element(self, name)
+      add_action_listener do
+        ControlPanel.app_value(name, value) unless value.nil?
+        proc.call(value) if proc
+      end
+      set_selected_index(initial_value ? elements.index(initial_value) : 0)
+    end
+
+    def value
+      get_selected_item
+    end
+  end
+
+  # Creates check-box elements for control_panel
+  class Checkbox < javax.swing.JCheckBox
+    def initialize(control_panel, name, proc = nil)
+      @control_panel = control_panel
+      super(name.to_s)
+      set_preferred_size(java.awt.Dimension.new(190, 64))
+      set_horizontal_alignment javax.swing.SwingConstants::CENTER
+      control_panel.add_element(self, name, false)
+      add_action_listener do
+        ControlPanel.app_value(name, value)
+        proc.call(value) if proc
+      end
+    end
+
+    # define value as checkbox state
+    def value
+      is_selected
+    end
+  end
+
+  # Creates button elements for control_panel
+  class Button < javax.swing.JButton
+    def initialize(control_panel, name, proc = nil)
+      super(name.to_s)
+      set_preferred_size(java.awt.Dimension.new(170, 64))
+      control_panel.add_element(self, name, false, true)
+      add_action_listener do
+        Processing.app.send(name)
+        proc.call(value) if proc
+      end
+    end
+  end
+
+  # class used to contain control_panel elements
+  class Panel < javax.swing.JFrame
+    java_import javax.swing.UIManager
+
+    attr_accessor :elements, :panel
+
+    def initialize
+      super()
+      @elements = []
+      @panel = javax.swing.JPanel.new(java.awt.FlowLayout.new(1, 0, 0))
+      feel
+    end
+
+    def display
+      add panel
+      set_size 200, 30 + (64 * elements.size)
+      set_default_close_operation javax.swing.JFrame::HIDE_ON_CLOSE
+      set_resizable false
+      xoffset = Processing.app.width + 10
+      set_location(xoffset, 0) unless xoffset > Processing.app.displayWidth
+      panel.visible = true
+    end
+
+    def add_element(element, name, has_label = true, _button_ = false)
+      if has_label
+        label = javax.swing.JLabel.new("<html><br><b>#{name}</b></html>")
+        panel.add label
+      end
+      elements << element
+      panel.add element
+      has_label ? label : nil
+    end
+
+    def remove
+      remove_all
+      dispose
+    end
+
+    def title(name)
+      set_title(name)
+    end
+
+    def slider(name, range = 0..100, initial = nil, &block)
+      Slider.new(self, name, range, initial, block || nil)
+    end
+
+    def menu(name, elements, initial_value = nil, &block)
+      Menu.new(self, name, elements, initial_value, block || nil)
+    end
+
+    def checkbox(name, initial_value = false, &block)
+      checkbox = Checkbox.new(self, name, block || nil)
+      checkbox.do_click if initial_value == true
+    end
+
+    def button(name, &block)
+      Button.new(self, name, block || nil)
+    end
+
+    def look_feel(lf)
+      feel(lf)
+    end
+
+    private
+
+    def feel(lf = 'metal')
+      lafinfo = javax.swing.UIManager.getInstalledLookAndFeels
+      laf = lafinfo.to_ary.find do |info|
+        info.name =~ Regexp.new(Regexp.escape(lf), Regexp::IGNORECASE)
+      end
+      javax.swing.UIManager.setLookAndFeel(laf.class_name)
+    end
+  end
+
+  # instance methods module
+  module InstanceMethods
+    def control_panel
+      @control_panel ||= ControlPanel::Panel.new
+      return @control_panel unless block_given?
+      yield(@control_panel)
+      @control_panel.display
+      @control_panel.set_visible true
+      @control_panel # for legacy compat
+    end
+  end
+end
+
+Processing::App.include(ControlPanel::InstanceMethods)