ruby-processing 2.5.0 → 2.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a5b8a868675fde6dc0132b818e7587a83225334c
-  data.tar.gz: e8df4b54e6a1cd9a20b8c0595e659540a3245f34
+  metadata.gz: 2afd84f1f31d6bb5a7646833da3198a47d36c288
+  data.tar.gz: eb51a2021e9294b6976de2b755e5b0ff90a81d9e
 SHA512:
-  metadata.gz: 452ebce774bac88364da71c0800ed75cabb3017282d97adf2a0cf71b421c121e162a145d56c92974e12eb7b82358d204454c599cd86dee2f06418320cac90144
-  data.tar.gz: e409850694f47b0b6acacd3f46d9fad87bfac2a2dca2a0ae238443828c14a7c5097f70157799f3a4501f6606cc9fcd6b4d6841161bada1985365996945ecf876
+  metadata.gz: f4fa0f3ac500132fcd125e67adc181de0706464431809fe96369d73432b2379b40a9edfef07a1dc19dfa030eafa77be5757920e22877088ab51ef8256d108ebe
+  data.tar.gz: 395804d382878458e4e9e2dc001c35cc1c6d81367ab4604a850ed636c1b334c2401e3c1cc6c68963178cc597c4422483dd51ce50665156cb310c7ddf673caf18

data/lib/ruby-processing/app.rb

@@ -53,22 +53,23 @@ module Processing
       if methods_to_alias.keys.include?(method_name)
         alias_method methods_to_alias[method_name], method_name
       end
-    end
-
-
-    # Class methods that we should make available in the instance.
-    [:map, :pow, :norm, :lerp, :second, :minute, :hour, :day, :month, :year,
-      :sq, :constrain, :dist, :blend_color, :degrees, :radians, :mag, :println,
-      :hex, :min, :max, :abs, :binary, :ceil, :nf, :nfc, :nfp, :nfs,
-      :norm, :round, :trim, :unbinary, :unhex ].each do |meth|
+    end    
+    
+    # Some class methods made available in the instance.
+     [:day, :month, :year, :sq, :mag, :println, :hex, :abs, :binary, :ceil,
+      :nf, :nfc, :nfp, :nfs, :round, :trim, :unbinary, :unhex ].each do |meth|
       method = <<-EOS
       def #{meth}(*args)
-      self.class.#{meth}(*args)
+        self.class.#{meth}(*args)
       end
       EOS
       eval method
     end
-
+    
+    # Above block deprecated from processing-2.5.1, you should in general prefer 
+    # ruby alternatives (eg t = Time.now and t.sec to second):-
+    # constrain, dist, map, norm, lerp and blend_color are implemented directly
+    
     # Handy getters and setters on the class go here:
     def self.sketch_class;  @sketch_class;        end
     @@full_screen = false
@@ -83,10 +84,6 @@ module Processing
       @sketch_class = subclass
     end
 
-    def self.has_slider(*args) #:nodoc:
-      raise "has_slider has been replaced with a nicer control_panel library. Check it out."
-    end
-
     @@library_loader = LibraryLoader.new
     class << self
       def load_libraries(*args)
@@ -109,14 +106,15 @@ module Processing
 
     def library_loaded?(library_name)
       self.class.library_loaded?(library_name)
-    end
-
-    # When you make a new sketch, you pass in (optionally),
-    # a width, height, x, y, title, and whether or not you want to
-    # run in full-screen.
-    #
-    # This is a little different than Processing where height
-    # and width are declared inside the setup method instead.
+    end    
+
+    # It is 'NOT' usually necessary to directly pass options to a sketch, it 
+    # gets done automatically for you. Since processing-2.0 you should prefer
+    # setting the sketch width and height and renderer using the size method,
+    # in the sketch (as with vanilla processing), which should be the first 
+    # argument in setup. Sensible options to pass are x and y to locate sketch
+    # on the screen, or full_screen: true (prefer new hash syntax)
+   
     def initialize(options={})
       super()
       $app = self
@@ -132,8 +130,11 @@ module Processing
         close
       end
 
-      # for the list of all available args, see
-      # http://processing.org/reference/
+      # For the list of all available args, see:-
+      # http://processing.org/reference/, however not all convenience functions
+      # are implemented in ruby-processing (you should in general prefer ruby
+      # alternatives when available and methods using java reflection, are best
+      # avoided entirely)
 
       args = []
       @width, @height = options[:width], options[:height]
@@ -144,7 +145,7 @@ module Processing
       @render_mode  ||= JAVA2D
       x = options[:x] || 0
       y = options[:y] || 0
-      args << "--location=#{x}, #{y}"
+      args << "--location=#{x},#{y}"  # important no spaces here
       title = options[:title] || File.basename(SKETCH_PATH).sub(/(\.rb)$/, '').titleize
       args << title
       PApplet.run_sketch(args, self)
@@ -183,7 +184,6 @@ module Processing
       self.frame.dispose
     end
 
-
     private
 
     # Mix the Processing::Proxy into any inner classes defined for the

data/lib/ruby-processing/exporters/base_exporter.rb

@@ -86,11 +86,13 @@ module Processing
         matchdata = code.match(/^.*[^::\.\w](require_relative|require|load)\b.*$/)
         break unless matchdata
         line = matchdata[0].gsub('__FILE__', "'#{@main_file_path}'")
-        line = line.gsub(/\b(require_relative|require|load)\b/, 'partial_paths << ')
-        eval(line)
-        where = "{#{local_dir}/,}{#{partial_paths.join(',')}}"
-        where += '.{rb,jar}' unless line =~ /\.[^.]+$/
-        requirements += Dir[where]
+        if (line =~ /\b(require_relative|require|load)\b/)
+          ln = line.gsub(/\b(require_relative|require|load)\b/, '') 
+          partial_paths << ln
+          where = "{#{local_dir}/,}{#{partial_paths.join(',')}}"
+          where += '.{rb,jar}' unless line =~ /\.[^.]+$/
+          requirements += Dir[where]
+        end
         code = matchdata.post_match
       end
       requirements

data/lib/ruby-processing/helper_methods.rb

@@ -60,9 +60,86 @@ module Processing
       if block_given?
         Thread.new *args, &block
       else
-        raise ArgumentError, 'thread must be called with a block' , caller
+        fail ArgumentError, 'thread must be called with a block' , caller
       end
     end
+    
+     # explicitly provide 'processing.org' map instance method
+    def map(value, start1, stop1, start2, stop2)
+      start2 + (stop2 - start2) * ((value - start1).to_f / (stop1 - start1))
+    end
+
+    # explicitly provide 'processing.org' norm instance method
+    def norm(value, start, stop)
+      (value - start).to_f / (stop - start)
+    end
+
+    # explicitly provide 'processing.org' lerp instance method
+    def lerp(start, stop, amt)
+      start + (stop - start) * amt
+    end
+
+    # explicitly provide 'processing.org' min instance method
+    # to return a float:- a, b and c need to be floats
+
+    def min(*args)
+      args.min { |a,b| a <=> b }
+    end
+
+    # explicitly provide 'processing.org' max instance method
+    # to return a float:- a, b and c need to be floats
+
+    def max(*args)
+      args.max { |a, b| a <=> b }
+    end
+
+    # explicitly provide 'processing.org' dist instance method
+    def dist(*args)
+      alen = args.length
+      return Math.hypot(args[0] - args[2], args[1] - args[3]) if alen == 4
+      return Math.sqrt((args[0] - args[3]) * (args[0] - args[3]) +
+          (args[1] - args[4]) * (args[1] - args[4]) +
+          (args[2] - args[5]) * (args[2] - args[5])) if alen == 6
+      fail ArgumentError, 'takes 4 or 6 parameters'
+    end
+
+    # explicitly provide 'processing.org' constrain instance method
+    # to return a float:- amt, low and high need to be floats
+    def constrain(amt, low, high)
+      (amt < low) ? low : ((amt > high) ? high : amt)
+    end
+
+    # explicitly provide 'processing.org' pow instance method
+    def pow(x, exp)
+      # warn 'pow(x, exp) is deprecated use x**exp to avoid this warning'
+      x**exp
+    end
+
+    # explicitly provide 'processing.org' radians instance method
+    def radians(theta)
+      # warn 'radians(theta) is deprecated use theta.radians to avoid this warning'
+      theta.radians
+    end
+    
+    def hour
+      # warn 'deprecated use t = Time.now and t.hour'
+      PApplet.hour
+    end
+    
+    def second
+      # warn 'deprecated use t = Time.now and t.sec'
+      PApplet.second
+    end
+    
+    def minute
+      # warn 'deprecated use t = Time.now and t.min'
+      PApplet.minute
+    end
+    
+    # Uses PImage class method under hood
+    def blend_color(c1, c2, mode)
+      PImage.blendColor(c1, c2, mode)
+    end
 
     # There's just so many functions in Processing,
     # Here's a convenient way to look for them.
@@ -86,8 +163,6 @@ module Processing
       field.set_value(java_self, path || SKETCH_ROOT)
     end
 
-
-
     # Fix java conversion problems getting the last key
     # If it's ASCII, return the character, otherwise the integer
     def key

data/lib/ruby-processing/version.rb

@@ -1,3 +1,3 @@
 module RubyProcessing
-  VERSION = '2.5.0'
+  VERSION = '2.5.1'
 end

data/lib/templates/application/run.erb

@@ -1,5 +1,5 @@
 #!/bin/sh
-APPDIR=$(dirname '$0')
-export EXPORTED='true'
-cd '$APPDIR/lib'
-java -cp "<%= @linux_class_path %>" org.jruby.Main ../lib/ruby-processing/runners/run.rb <%= @main_file %>
+APPDIR=$(dirname "$0")
+export EXPORTED="true"
+cd "$APPDIR/lib"
+java -cp "<%= @linux_class_path %>" org.jruby.Main ruby-processing/runners/run.rb <%= @main_file %>

data/samples/contributed/elegant_ball.rb

@@ -3,17 +3,22 @@
 # Ben Notorianni aka lazydog
 #
 
+# elegant.rb
+
+
 load_library :vecmath
 
-attr_reader :renderer
+attr_reader :start_t, :renderer
 
-def setup
+def setup()
   size(800, 800, P3D)
   @renderer = AppRender.new(self) 
   color_mode(RGB, 1)
 end
 
-def draw
+
+
+def draw()
   #background(0.25)
   background(0)
   # Move the origin so that the scene is centered on the screen.
@@ -23,7 +28,7 @@ def draw
   # Rotate the local coordinate system.
   smooth_rotation(5.0, 6.7, 7.3)
   # Draw the inner object.
-  no_stroke
+  no_stroke()
   fill(smooth_colour(10.0, 12.0, 7.0))
   draw_icosahedron(5, 60.0, false)
   # Rotate the local coordinate system again.
@@ -37,18 +42,21 @@ end
 def setup_lights
   ambient_light(0.025, 0.025, 0.025)
   directional_light(0.2, 0.2, 0.2, -1, -1, -1)
-  spot_light(1.0, 1.0, 1.0, -200, 0, 300, 1, 0, -1, PI/4, 20)
+  spot_light(1.0, 1.0, 1.0, -200, 0, 300, 1, 0, -1, Math::PI/4, 20)
 end
 
 ##
 # Generate a vector whose components change smoothly over time in the range [ 0, 1 ].
-# Each component uses a Math.sin function to map the current time in milliseconds somewhere
+# Each component uses a Math.sin() function to map the current time in milliseconds somewhere
 # in the range [ 0, 1 ].A 'speed' factor is specified for each component.
 #
 def smooth_vector(s1, s2, s3)
-  mills = millis * 0.00003
-  rot = ->(a){0.5 * Math.sin(mills * a) + 0.5}
-  Vec3D.new(rot.call(s1), rot.call(s2), rot.call(s3))
+  mills = millis * 0.00003 ## Lazydogs factor
+  # mills = millis * 0.0000001 ## worked for me a bit slower!!
+  x = 0.5 * Math.sin(mills * s1) + 0.5
+  y = 0.5 * Math.sin(mills * s2) + 0.5
+  z = 0.5 * Math.sin(mills * s3) + 0.5
+  Vec3D.new(x, y, z)
 end
 
 ##
@@ -62,13 +70,13 @@ end
 
 ##
 # Rotate the current coordinate system.
-# Uses smooth_vector to smoothly animate the rotation.
+# Uses smooth_vector() to smoothly animate the rotation.
 #
 def smooth_rotation(s1, s2, s3)
   r1 = smooth_vector(s1, s2, s3)
-  rotate_x(2.0 * PI * r1.x)
-  rotate_y(2.0 * PI * r1.y)
-  rotate_x(2.0 * PI * r1.z)
+  rotate_x(2.0 * Math::PI * r1.x)
+  rotate_y(2.0 * Math::PI * r1.y)
+  rotate_x(2.0 * Math::PI * r1.z)
 end
 
 ##
@@ -82,23 +90,25 @@ def draw_icosahedron(depth, r, spherical)
   gr = (1.0 + Math.sqrt(5.0)) / 2.0
   h = r / Math.sqrt(1.0 + gr * gr)
   v =
-  [
-  Vec3D.new(0, -h, h * r), Vec3D.new(0, -h, -h * r), Vec3D.new(0, h, -h * r), Vec3D.new(0, h, h * r),
-  Vec3D.new(h, -h * r, 0), Vec3D.new(h, h * r, 0), Vec3D.new(-h, h * r, 0), Vec3D.new(-h, -h * r, 0),
-  Vec3D.new(-h * r, 0, h), Vec3D.new(-h * r, 0, -h), Vec3D.new(h * r, 0, -h), Vec3D.new(h * r, 0, h)
+    [
+    Vec3D.new(0, -h, h*gr), Vec3D.new(0, -h, -h*gr), Vec3D.new(0, h, -h*gr), Vec3D.new(0, h, h*gr),
+    Vec3D.new(h, -h*gr, 0), Vec3D.new(h, h*gr, 0), Vec3D.new(-h, h*gr, 0), Vec3D.new(-h, -h*gr, 0),
+    Vec3D.new(-h*gr, 0, h), Vec3D.new(-h*gr, 0, -h), Vec3D.new(h*gr, 0, -h), Vec3D.new(h*gr, 0, h)
   ]
-  
+
   # Draw the 20 triangular faces of the icosahedron.
-  r = 0.0 unless spherical
-  
+  unless spherical then
+    r = 0.0
+  end
+
   begin_shape(TRIANGLES)
-    
-  draw_triangle(depth, r, v[0], v[7], v[4])
+   
+  draw_triangle(depth, r, v[0], v[7],v[4])
   draw_triangle(depth, r, v[0], v[4], v[11])
   draw_triangle(depth, r, v[0], v[11], v[3])
   draw_triangle(depth, r, v[0], v[3], v[8])
   draw_triangle(depth, r, v[0], v[8], v[7])
-  
+
   draw_triangle(depth, r, v[1], v[4], v[7])
   draw_triangle(depth, r, v[1], v[10], v[4])
   draw_triangle(depth, r, v[10], v[11], v[4])
@@ -109,14 +119,14 @@ def draw_icosahedron(depth, r, spherical)
   draw_triangle(depth, r, v[8], v[9], v[6])
   draw_triangle(depth, r, v[9], v[7], v[8])
   draw_triangle(depth, r, v[7], v[1], v[9])
-  
+
   draw_triangle(depth, r, v[2], v[1], v[9])
   draw_triangle(depth, r, v[2], v[10], v[1])
   draw_triangle(depth, r, v[2], v[5], v[10])
   draw_triangle(depth, r, v[2], v[6], v[5])
   draw_triangle(depth, r, v[2], v[9], v[6])
-  
-  end_shape
+ 
+  end_shape()
 end
 
 ##
@@ -124,8 +134,8 @@ end
 # If depth is 1 then draw the triangle otherwise subdivide first.
 #
 def draw_triangle(depth, r, p1, p2, p3)
-  
-  if (depth == 1)
+
+  if (depth == 1) then
     p1.to_vertex(renderer)
     p2.to_vertex(renderer)
     p3.to_vertex(renderer)
@@ -134,15 +144,15 @@ def draw_triangle(depth, r, p1, p2, p3)
     v1 = (p1 + p2) * 0.5
     v2 = (p2 + p3) * 0.5
     v3 = (p3 + p1) * 0.5
-    unless (r == 0.0)
-      # Project the verticies out onto the sphere with radius r.
-      v1.normalize!
-      v1 *= r
-      v2.normalize!
-      v2 *= r
-      v3.normalize!
-      v3 *= r
-    end
+  unless (r == 0.0) then
+    # Project the verticies out onto the sphere with radius r.
+    v1.normalize!
+    v1 *= r
+    v2.normalize!
+    v2 *= r
+    v3.normalize!
+    v3 *= r
+  end
     ## Generate the next level of detail
     depth -= 1
     draw_triangle(depth, r, p1, v1, v3)

data/samples/contributed/tree.rb

@@ -12,10 +12,6 @@ def setup
   @frame_time = nil
 end
 
-def radians(x)
-  return x * (Math::PI / 180)
-end
-
 def draw
   t = Time.now
   if @frame_time
@@ -29,7 +25,7 @@ def draw
   # Let's pick an angle 0 to 90 degrees based on the mouse position
   a = (@x / width) * 90
   # Convert it to radians
-  @theta = radians(a)
+  @theta = a.radians
   # Start the tree from the bottom of the screen
   translate(width / 2, height)
   # Draw a line 60 pixels

data/samples/external_library/java_processing/custom/README.md

@@ -1,15 +1,16 @@
 Building the custom nn Library
 ==============================
 This is an example of a java library that you can build yourself with the included Rakefile.
-Ideally you will both have ant and jruby installed (you should also have a jdk-7+ installed).
+You need a jdk, a system version of jruby and the ruby-compiler gem to build the nn library 
+(see ext dir).
+Compiling and building the jar is dead easy just issue the following command in a console.
 
-If you have done all of that compiling and building jar is dead easy just issue the following command in a console.
-
-`jruby -S rake`
+`jruby -S rake compile`
 
 you may also need to set JAVA_HOME to point to your jdk eg
 
-`export JAVA_HOME=/opt/jdk1.7.0_51` for linux users 
+`export JAVA_HOME=/opt/jdk1.7.0_65` for linux users 
 
+You can even run the sketch using `rake`, with the `:run` task `rake run` and tidy up when your are done `rake clean`
 
 This example was taken from [The Nature of Code](https://github.com/shiffman/The-Nature-of-Code) by Dan Shiffman, except the example has been rubified (and even the java code was doctored to be more up to date, and to prefer double to float).