processing.rb 1.1.1

data/bin/setup_processingrb_examples

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+require_relative '../lib/sketch_runner/config.rb'
+
+FileUtils.remove_dir(SketchRunner::EXAMPLES_DEST_DIR, true)
+FileUtils.cp_r(SketchRunner::EXAMPLES_SRC_DIR, SketchRunner::EXAMPLES_DEST_DIR)
+
+puts "copied the examples to #{SketchRunner::EXAMPLES_DEST_DIR}"

data/examples/01_simple_sketch.rb

@@ -0,0 +1,32 @@
+require 'processing'
+
+# An example of the basic sketch structure
+class Sketch < Processing::SketchBase
+  LINE_RADIUS = 8
+  LINE_SPEED = 3
+
+  def setup
+    size(480, 240)
+    background(96)
+    no_stroke
+
+    @x = @y = LINE_RADIUS
+    @vx = @vy = LINE_SPEED
+  end
+
+  def draw
+    fill(96, 8)
+    rect(0, 0, width, height)
+
+    @x += @vx
+    @y += @vy
+
+    @vx *= -1 if @x <= LINE_RADIUS || @x >= width - LINE_RADIUS
+    @vy *= -1 if @y <= LINE_RADIUS || @y >= height - LINE_RADIUS
+
+    fill(255, 204, 0)
+    ellipse(@x, @y, LINE_RADIUS * 2, LINE_RADIUS * 2)
+  end
+end
+
+Processing.start(Sketch.new)

data/examples/02_input_handling.rb

@@ -0,0 +1,49 @@
+require 'processing'
+
+# An example of handling keyboard and mouse input
+class Sketch < Processing::SketchBase
+  CIRCLE_NUM = 40
+  MIN_RADIUS, MAX_RADIUS = 40, 80
+  MIN_ALPHA, MAX_ALPHA = 64, 255
+
+  def setup
+    size(600, 400)
+    background(32, 96, 160)
+    fill(255)
+    stroke_weight(4)
+
+    @pos = []
+
+    text_size(30)
+    text_align(CENTER)
+    text("Press 'r' to Reload", width / 2, height - 15)
+  end
+
+  def draw
+    # initialize the position array when the mouse moves for the first time
+    if @pos.empty?
+      return if mouse_x == 0 && mouse_y == 0
+
+      (0...CIRCLE_NUM).each do
+        @pos << Processing::PVector.new(mouse_x, mouse_y)
+      end
+    end
+
+    @pos[frame_count % CIRCLE_NUM].set(mouse_x, mouse_y)
+
+    (0...CIRCLE_NUM).each do |i|
+      pos = @pos[(frame_count + i + 1) % CIRCLE_NUM]
+      rad = map(i, 0, CIRCLE_NUM, MAX_RADIUS, MIN_RADIUS)
+      alpha = map(i, 0, CIRCLE_NUM, MIN_ALPHA, MAX_ALPHA)
+
+      stroke(0, 128, 255, alpha)
+      ellipse(pos.x, pos.y, rad, rad)
+    end
+  end
+
+  def key_pressed
+    Processing.reload if key == 'r'
+  end
+end
+
+Processing.start(Sketch.new, pos: [300, 300])

data/examples/03_multi_file.rb

@@ -0,0 +1,44 @@
+require 'processing'
+
+require_relative 'modules/moving_box'
+
+# An example of splitting the sketch into multiple files
+class Sketch < Processing::SketchBase
+  CUBE_NUM = 200
+
+  def setup
+    size(640, 360, OPENGL)
+    background(0)
+    no_stroke
+
+    @angle = 0
+    @boxes = []
+
+    (0...CUBE_NUM).each do |i|
+      @boxes[i] = MovingBox.new(
+        self,
+        random(-280, 280), random(-280, 280), random(-280, 280),
+        random(5, 25), random(5, 25), random(5, 25)
+      )
+    end
+  end
+
+  def draw
+    background(192, 97, 70)
+    fill(200)
+
+    point_light(128, 169, 125, -65, 60, -150)
+    point_light(69, 117, 115, 65, -60, 100)
+    ambient_light(80, 58, 71)
+
+    translate(width / 2, height / 2, -200 + mouse_x * 0.65)
+    rotate_y(radians(@angle))
+    rotate_x(radians(@angle))
+
+    @boxes.each(&:draw)
+
+    @angle += 0.2
+  end
+end
+
+Processing.start(Sketch.new, topmost: true, pos: [300, 300])

data/examples/04_builtin_library.rb

@@ -0,0 +1,48 @@
+require 'processing'
+require_relative 'modules/textured_cube'
+
+Processing.load_library 'video'
+Processing.import_package 'processing.video', 'Video'
+
+# An example of using Processing-buildin libraries
+class Sketch < Processing::SketchBase
+  include TexturedCube
+
+  MOVIE1 = Processing.sketch_path('data/cat.mov')
+  MOVIE2 = Processing.sketch_path('data/dog.mov')
+
+  def setup
+    size(800, 400, OPENGL)
+    no_stroke
+
+    @mov1 = Video::Movie.new(self, MOVIE1)
+    @mov1.loop
+
+    @mov2 = Video::Movie.new(self, MOVIE2)
+    @mov2.loop
+  end
+
+  def draw
+    background(80, 100, 180)
+    lights
+
+    @mov1.read if @mov1.available
+    @mov2.read if @mov2.available
+
+    push_matrix
+
+    translate(220, 200, -50)
+    rotate_x(frame_count / 200.0)
+    rotate_y(frame_count / 150.0)
+    textured_cube(220, @mov1, 0.22, 0, 0.78, 1)
+
+    pop_matrix
+
+    translate(580, 200, -50)
+    rotate_x(frame_count / 200.0)
+    rotate_y(frame_count / 150.0)
+    textured_cube(220, @mov2, 0.22, 0, 0.78, 1)
+  end
+end
+
+Processing.start(Sketch.new, topmost: true, pos: [300, 300])

data/examples/05_external_library.rb

@@ -0,0 +1,89 @@
+require 'processing'
+
+Processing.load_library 'handy'
+Processing.import_package 'org.gicentre.handy', 'Handy'
+
+BALL_NUM = 6
+BALL_COLORS = [[255, 0, 0], [255, 255, 0], [64, 64, 255]]
+
+# An example of using external libraries for Processing
+class Sketch < Processing::SketchBase
+  attr_reader :handy
+
+  def setup
+    size(400, 400)
+
+    @handy = Handy::HandyRenderer.new(self)
+
+    @balls = []
+    (0...BALL_NUM).each { |i| @balls << Ball.new(self, i) }
+  end
+
+  def draw
+    background(234, 215, 182)
+
+    fill(0, 255, 0)
+    @handy.instance_eval do
+      rect(20, 20, 360, 20)
+      rect(20, 360, 360, 20)
+      rect(20, 40, 20, 320)
+      rect(360, 40, 20, 320)
+    end
+
+    @balls.each(&:draw)
+  end
+
+  def key_pressed
+    Processing.reload if key == 'r'
+  end
+end
+
+# Bouncing ball
+class Ball
+  def initialize(sketch, id)
+    @sketch = sketch
+
+    @x, @y = @sketch.random(100, 300), @sketch.random(100, 300)
+    @vx, @vy = @sketch.random(-6, 6), @sketch.random(-6, 6)
+
+    @size = @sketch.random(60, 100)
+    @radius = @size / 2.0
+
+    @color = BALL_COLORS[id % BALL_COLORS.size]
+
+    @min_x = @min_y = 40 + @radius
+    @max_x = @max_y = 360 - @radius
+  end
+
+  def draw
+    @x += @vx
+    @y += @vy
+
+    @vy += 0.1
+
+    if @x < @min_x
+      @x = @min_x
+      @vx = -@vx
+    end
+
+    if @x > @max_x
+      @x = @max_x
+      @vx = -@vx
+    end
+
+    if @y < @min_y
+      @y = @min_y
+      @vy = -@vy
+    end
+
+    if @y > @max_y
+      @y = @max_y
+      @vy *= -0.99
+    end
+
+    @sketch.fill(*@color)
+    @sketch.handy.ellipse(@x, @y, @size, @size)
+  end
+end
+
+Processing.start(Sketch.new, topmost: true, pos: [300, 300])

data/examples/libraries/handy/library.properties

@@ -0,0 +1,43 @@
+# The name of your library as you want it formatted
+name = handy
+
+# List of authors. Links can be provided using the syntax [author name](url)
+authorList = [Jo Wood](http://gicentre.org/)
+
+# A website for your library
+url = http://www.gicentre.org/handy
+
+# The category of your library, must be one of the following:
+#   "Sound"          "Import / Export"          "Simulation / Math"
+#   "Tools"          "Hardware Interface"       "Typography / Geometry"
+#   "Animation"      "Graphic Interface"        "Computer Vision / Video" 
+#   "3D"             "Compilation"              "Data / Protocols"   
+# 
+# If a value other than those listed is used, your library will listed as "Other."
+category = "Graphic Interface"
+
+# A short sentence (fragment) to summarize the library's function. This will be
+# shown from inside the PDE when the library is being installed. Avoid repeating
+# the name of your library here. Also, avoid saying anything redundant like
+# mentioning that its a library.
+sentence = Hand-drawn sketchy rendering.
+
+# Additional information suitable for the Processing website. The value of
+# 'sentence' always will be prepended, so you should start by writing the
+# second sentence here. If your library only works on certain operating systems,
+# mention it here.
+paragraph = Allows you to produce graphics with a hand-drawn appearance. Appearance can be customised to produce a variety of styles including pencil, ball-point pen and marker pen appearance. For documentation and examples, see the [handy pages](http://www.gicentre.org/handy/).
+
+# Links in the 'sentence' and 'paragraph' attributes can be inserted using the
+# same syntax as for authors. That is, [here is a link to Processing](http://processing.org/)
+
+# A version number that increments once with each release. This
+# is used to compare different versions of the same library, and
+# check if an update is available. You should think of it as a
+# counter, counting the total number of releases you've had.
+# This must be parsable as an int
+version = 1
+
+# The version as the user will see it. If blank, the version attribute will be used here
+# This is treated as a String
+prettyVersion = 1.0

data/examples/modules/moving_box.rb

@@ -0,0 +1,23 @@
+# Draws a moving box of the speficied size
+class MovingBox
+  def initialize(sketch, x, y, z, w, h, d)
+    @sketch = sketch
+    @x, @y, @z = x, y, z
+    @w, @h, @d = w, h, d
+  end
+
+  def draw
+    x, y, z = @x, @y, @z
+    w, h, d = @w, @h, @d
+
+    @sketch.instance_eval do
+      push_matrix
+
+      x += sin(frame_count / 10.0 + y) * 10.0
+      translate(x, y, z)
+      box(w, h, d)
+
+      pop_matrix
+    end
+  end
+end

data/examples/modules/textured_cube.rb

@@ -0,0 +1,47 @@
+# Draws the cube with the specified texture
+module TexturedCube
+  def textured_cube(size, pimage, u1, v1, u2, v2)
+    w = h = d = size / 2.0
+
+    u1 *= pimage.width.to_f
+    v1 *= pimage.height.to_f
+    u2 *= pimage.width.to_f
+    v2 *= pimage.height.to_f
+
+    begin_shape(Processing::SketchBase::QUADS)
+
+    texture(pimage)
+
+    vertex(-w, -h, d, u1, v1)
+    vertex(w, -h, d, u2, v1)
+    vertex(w, h, d, u2, v2)
+    vertex(-w, h, d, u1, v2)
+
+    vertex(w, -h, -d, u1, v1)
+    vertex(-w, -h, -d, u2, v1)
+    vertex(-w, h, -d, u2, v2)
+    vertex(w, h, -d, u1, v2)
+
+    vertex(-w, h, d, u1, v1)
+    vertex(w, h, d, u2, v1)
+    vertex(w, h, -d, u2, v2)
+    vertex(-w, h, -d, u1, v2)
+
+    vertex(-w, -h, -d, u1, v1)
+    vertex(w, -h, -d, u2, v1)
+    vertex(w, -h, d, u2, v2)
+    vertex(-w, -h, d, u1, v2)
+
+    vertex(w, -h, d, u1, v1)
+    vertex(w, -h, -d, u2, v1)
+    vertex(w, h, -d, u2, v2)
+    vertex(w, h, d, u1, v2)
+
+    vertex(-w, -h, -d, u1, v1)
+    vertex(-w, -h, d, u2, v1)
+    vertex(-w, h, d, u2, v2)
+    vertex(-w, h, -d, u1, v2)
+
+    end_shape
+  end
+end

data/lib/processing.rb

@@ -0,0 +1,8 @@
+if Object.const_defined? :SketchRunner
+  require_relative 'processing/system'
+  require_relative 'processing/sketch_base'
+else
+  require_relative 'sketch_runner/config'
+  require_relative 'sketch_runner/setup'
+  require_relative 'sketch_runner/launch'
+end

data/lib/processing/sketch_base.rb

@@ -0,0 +1,54 @@
+# Provides the classes and methods for a Processing sketch
+module Processing
+  include_package 'processing.core'
+  include_package 'processing.opengl'
+
+  # The base class of a Processing sketch
+  class SketchBase < PApplet
+    %w(displayHeight displayWidth frameCount keyCode
+       mouseButton mouseX mouseY pmouseX pmouseY).each do |name|
+      sc_name = name.split(/(?![a-z])(?=[A-Z])/).map(&:downcase).join('_')
+      alias_method sc_name, name
+    end
+
+    def self.method_added(name)
+      name = name.to_s
+      if name.include?('_')
+        lcc_name = name.split('_').map(&:capitalize).join('')
+        lcc_name[0] = lcc_name[0].downcase
+        alias_method lcc_name, name if lcc_name != name
+      end
+    end
+
+    def method_missing(name, *args)
+      self.class.__send__(name, *args) if PApplet.public_methods.include?(name)
+    end
+
+    def get_field_value(name)
+      java_class.declared_field(name).value(to_java(PApplet))
+    end
+
+    def initialize
+      super
+      SketchRunner.sketch_instances << self
+    end
+
+    def frame_rate(fps = nil)
+      return get_field_value('frameRate') unless fps
+      super(fps)
+    end
+
+    def key
+      code = get_field_value('key')
+      code < 256 ? code.chr : code
+    end
+
+    def key_pressed?
+      get_field_value('keyPressed')
+    end
+
+    def mouse_pressed?
+      get_field_value('mousePressed')
+    end
+  end
+end