ruby-processing 1.0.11 → 2.4.1

data/samples/processing_app/basics/web/embedded_links.rb

@@ -3,56 +3,50 @@
 # Click on the left button to open a different URL in the same window (Only
 # works online). Click on the right button to open a URL in a new browser window.  
 
-class EmbeddedLinks < Processing::App
-
-  def setup
-    
-    size 200, 200
-    
-  end
-  
-  def draw
-  
-  	background 204
-  	
-  	no_fill
-  	fill 255 if @over_left_button
-  	
-  	rect 20, 60, 75, 75
-  	rect 50, 90, 15, 15
-  	
-  	no_fill
-  	fill 255 if @over_right_button
-  	
-  	rect 105,  60,  75,  75
-  	line 135, 105, 155,  85
-  	line 140,  85, 155,  85
-  	line 155,  85, 155, 100
-  
-  end
+def setup
   
-  def mouse_pressed
-  	link "http://www.processing.org"         if @over_left_button
-  	link "http://www.processing.org", "_new" if @over_right_button
-  end
+  size 640, 360
   
-  def mouse_moved 
-  	check_buttons 
-  end
+end
+
+def draw
+  size 200, 200
+  background 204  	
+  no_fill
+  fill 255 if @over_left_button
   
-  def mouse_dragged
-  	check_buttons
-  end
+  rect 20, 60, 75, 75
+  rect 50, 90, 15, 15
   
-  def check_buttons
-  	@over_left_button  = inside? mouse_x, mouse_y,  20,  95, 60, 135
-  	@over_right_button = inside? mouse_x, mouse_y, 105, 180, 60, 135
-  end
+  no_fill
+  fill 255 if @over_right_button
   
-  def inside? ( x, y, l, r, t, b )
-  	return x > l && x < r && y > t && y < b
-  end
+  rect 105,  60,  75,  75
+  line 135, 105, 155,  85
+  line 140,  85, 155,  85
+  line 155,  85, 155, 100
   
 end
 
-EmbeddedLinks.new :title => "Embedded Links"
+def mouse_pressed
+  link "https://github.com/jashkenas/ruby-processing/wiki" if @over_left_button
+  link "https://github.com/jashkenas/ruby-processing/wiki", "_new" if @over_right_button
+end
+
+def mouse_moved 
+  check_buttons 
+end
+
+def mouse_dragged
+  check_buttons
+end
+
+def check_buttons
+  @over_left_button  = inside? mouse_x, mouse_y,  20,  95, 60, 135
+  @over_right_button = inside? mouse_x, mouse_y, 105, 180, 60, 135
+end
+
+def inside? ( x, y, l, r, t, b )
+  return x > l && x < r && y > t && y < b
+end
+

data/samples/processing_app/basics/web/loading_images.rb

@@ -1,25 +1,15 @@
 # Loading Images. 
 # 
-# Loading a recent image from the US National Weather Service. 
-# Notice the date in the upper left corner of the image. 
+# Loading ruby processing "blue ruby". 
 # Processing applications can only load images from the network
 # while running in the Processing environment. This example will 
-# not run in a web broswer and will only work when the computer
+# not run in a web browser and will only work when the computer
 # is connected to the Internet. 
 
-class LoadingImages < Processing::App
 
-  def setup
-  	
-  	size 200, 200
-  	
-  	background 255
-  	
-	img1 = load_image "http://s3.amazonaws.com/jashkenas/images/ruby.jpg"
-	
+def setup  	
+  size 200, 200  	
+  background 255  	
+	img1 = load_image "http://s3.amazonaws.com/jashkenas/images/ruby.jpg"	
 	image img1, 0, 45
-  end
-  
 end
-
-LoadingImages.new :title => "Loading Images"

data/samples/processing_app/demos/graphics/bezier_patch.rb

@@ -0,0 +1,227 @@
+# bezier bez_patch By Marius Watz:
+# http://www.openprocessing.org/sketch/57709
+# Normal calculation added by Andres Colubri
+# Direct port of sample code by Paul Bourke.
+# Original code: http://paulbourke.net/geometry/bezier/
+#
+# hit "spacebar" to generate a new shape and save current
+# translated for ruby-processing by Martin Prout January 2013
+#
+
+load_library :vecmath
+
+NI=4
+NJ=5
+RESI=NI*10
+RESJ=NJ*10
+
+attr_accessor :outp, :inp, :normp, :auto_normals, :arcball, :bez_patch
+ 
+def setup
+  size(1024, 768, P3D)
+  @arcball = ArcBall.new(width/2.0, height/2.0, min(width - 20, height - 20) * 0.5)
+  @auto_normals = false
+  build_geometry
+  @bez_patch = build_shape
+end
+ 
+def draw
+  background(255)
+  translate(width/2,height/2)
+  smooth(8)
+  lights
+  define_lights
+  scale(0.9)
+  update
+  no_stroke 
+  shape(bez_patch)
+end
+
+#######
+# use bez patch geometry to
+# create a vbo object (PShape)
+#######
+
+def build_shape
+  no_stroke
+  bez = create_shape
+  bez.begin_shape(QUAD_STRIP)
+  bez.fill(192, 192, 192) 
+  bez.ambient(20, 20, 20)
+  bez.specular(30)
+  (0 ... RESI - 1).each do |i|        
+    (0 ... RESJ).each do |j|
+      if (!auto_normals)
+        bez.normal(*normp[i][j])
+      end
+      bez.vertex(*outp[i][j])
+      bez.vertex(*outp[i+1][j])     
+    end    
+  end
+  bez.end_shape     
+  return bez   
+end
+
+##########
+# build geometry
+# for bez patch
+##########
+ 
+def build_geometry
+  @outp = []
+  @normp = []
+  @inp = []
+  uitang = PVector.new
+  ujtang = PVector.new
+  
+  (0 ... NI).each do |i|
+    row = Array.new  
+    (0 ... NJ).each do |j|
+      row << PVector.new(i, j, rand(-3.0 .. 3.0))  
+    end
+    inp << row
+  end
+  
+  (0 ... RESI).each do |i|
+    mui = i.fdiv(RESI - 1)
+    row = []
+    row_n = []
+    (0 ... RESJ).each do |j|
+      muj = j.fdiv(RESJ - 1)
+      vect = PVector.new
+      uitang.set(0, 0, 0)
+      ujtang.set(0, 0, 0)
+      (0 ... NI).each do |ki|
+        bi = bezier_blend(ki, mui, NI)
+        dbi = d_bezier_blend(ki, mui, NI)
+        (0 ... NJ).each do |kj|
+          bj = bezier_blend(kj, muj, NJ)
+          dbj = d_bezier_blend(kj, muj, NJ)
+          vect.x += (inp[ki][kj].x * bi * bj)
+          vect.y += (inp[ki][kj].y * bi * bj)
+          vect.z += (inp[ki][kj].z * bi * bj)
+           
+          uitang.x += (inp[ki][kj].x * dbi * bj)
+          uitang.y += (inp[ki][kj].y * dbi * bj)
+          uitang.z += (inp[ki][kj].z * dbi * bj)
+           
+          ujtang.x += (inp[ki][kj].x * bi * dbj)
+          ujtang.y += (inp[ki][kj].y * bi * dbj)
+          ujtang.z += (inp[ki][kj].z * bi * dbj)
+        end
+      end
+      vect.add(PVector.new(-NI/2,-NJ/2,0))
+      vect.mult(100)
+      row << vect.array()       
+      uitang.normalize
+      ujtang.normalize
+      row_n << uitang.cross(ujtang).array()     
+    end
+    @outp << row
+    @normp << row_n
+  end
+end
+ 
+def bezier_blend( k, mu,  n)
+  blend = 1.0 
+  nn = n
+  kn = k
+  nkn = n - k
+  
+  while (nn >= 1)
+    blend *= nn
+    nn -= 1
+    if (kn > 1)
+      blend = blend.fdiv(kn)
+      kn -= 1
+    end
+    if (nkn > 1)
+      blend = blend.fdiv(nkn)
+      nkn -= 1
+    end
+  end    
+  blend *= pow(mu, k.to_f) if (k > 0)
+  blend *= pow(1-mu, (n - k).to_f) if (n - k > 0)
+  return(blend)
+end
+
+def d_bezier_blend( k, mu,  n)
+  dblendf = 1.0
+  
+  nn = n
+  kn = k
+  nkn = n - k
+  
+  while (nn >= 1)
+    dblendf *= nn
+    nn -= 1
+    if (kn > 1)
+      dblendf  = dblendf.fdiv(kn)
+      kn -= 1
+    end
+    if (nkn > 1)
+      dblendf  = dblendf.fdiv(nkn)
+      nkn -= 1
+    end
+  end
+   
+  fk = 1
+  dk = 0
+  fnk = 1
+  dnk = 0   
+  if (k > 0)
+    fk = pow(mu, k.to_f)
+    dk = k * pow(mu, (k - 1).to_f)
+  end 
+  if (n - k > 0)
+    fnk = pow(1 - mu, (n - k).to_f)
+    dnk = (k - n)*pow(1 - mu, (n - k - 1).to_f)
+  end
+  dblendf *= (dk * fnk + fk * dnk)
+  
+  return(dblendf) 
+end
+
+######################
+# ArcBall control
+# and lighting + re-run
+######################
+
+def update
+  theta, x, y, z = arcball.update
+  rotate(theta, x, y, z)
+end
+
+def mouse_pressed
+  arcball.mouse_pressed(mouse_x, mouse_y)
+end
+
+def mouse_dragged
+  arcball.mouse_dragged(mouse_x, mouse_y)
+end
+
+def define_lights    
+  ambient_light(40, 40, 40)
+  point_light(30, 30, 30, 0, 0, 0)
+  directional_light(60, 60, 60, 1, 0, 0)
+  spot_light(30, 30, 30, 0, 40, 200, 0, -0.5, 0.5, PI / 2, 2)
+end
+
+def key_pressed                
+  case(key)
+  when ' '
+    save_frame("bezPatch.png")
+    build_geometry
+    @bez_patch = build_shape
+  when 'x'
+    arcball.select_axis(X)
+  when 'y'
+    arcball.select_axis(Y)
+  when 'z'
+    arcball.select_axis(Z)
+  end
+end
+
+def key_released
+  arcball.select_axis(-1)
+end

data/samples/processing_app/demos/graphics/data/frag.glsl

@@ -0,0 +1,30 @@
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2011-12 Ben Fry and Casey Reas
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+ */
+
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+varying vec4 vertColor;
+
+void main() {
+  gl_FragColor = vertColor;
+}

data/samples/processing_app/demos/graphics/data/java_args.txt

@@ -0,0 +1,2 @@
+-XX:CompileCommand=dontinline,org.jruby.runtime.invokedynamic.InvokeDynamicSupport::invocationFallback 
+

data/samples/processing_app/demos/graphics/data/vert.glsl

@@ -0,0 +1,31 @@
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2011-12 Ben Fry and Casey Reas
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+ */
+
+uniform mat4 transform;
+
+attribute vec4 vertex;
+attribute vec4 color;
+
+varying vec4 vertColor;
+
+void main() {
+  gl_Position = transform * vertex;    
+  vertColor = color;
+}

data/samples/processing_app/demos/graphics/low_level_gl.rb

@@ -0,0 +1,72 @@
+include_package 'java.nio'
+java_import 'processing.opengl.PGL'  
+
+
+attr_reader :sh, :vert_loc, :color_loc, :vert_data, :color_data
+
+def setup
+  size(640, 360, P3D)
+  
+  # Loads a shader to render geometry w/out
+  # textures and lights.
+  @sh = loadShader("frag.glsl", "vert.glsl")  
+  @vert_data = allocate_direct_float_buffer(12)  
+  @color_data = allocate_direct_float_buffer(12)
+end
+
+def draw
+  background(0)
+  
+  # The geometric transformations will be automatically passed 
+  # to the shader.
+  rotate(frame_count * 0.01, width, height, 0)
+  
+  update_geometry
+  
+  pgl = beginPGL
+  sh.bind
+  
+  @vert_loc = pgl.getAttribLocation(sh.glProgram, "vertex")
+  @color_loc = pgl.getAttribLocation(sh.glProgram, "color")
+  
+  pgl.enableVertexAttribArray(vert_loc)
+  pgl.enableVertexAttribArray(color_loc)
+
+  pgl.vertexAttribPointer(vert_loc, 4, PGL.FLOAT, false, 0, vert_data)
+  pgl.vertexAttribPointer(color_loc, 4, PGL.FLOAT, false, 0, color_data)
+  
+  pgl.drawArrays(PGL.TRIANGLES, 0, 3)
+  
+  pgl.disableVertexAttribArray(vert_loc)
+  pgl.disableVertexAttribArray(color_loc)
+  
+  sh.unbind  
+  
+  endPGL
+end
+
+def update_geometry
+  # Vertex 1
+  vertices = [0, 0, 0, 1]
+  colors = [1, 0, 0, 1]
+  
+  # Corner 2
+  vertices += [width/2, height, 0, 1]
+  colors += [0, 1, 0, 1]
+  
+  # Corner 3
+  vertices += [width, 0, 0, 1]
+  colors += [0, 0, 1, 1]
+  
+  vert_data.rewind
+  vert_data.put(vertices.to_java :float)
+  vert_data.position(0)
+  
+  color_data.rewind
+  color_data.put(colors.to_java :float)
+  color_data.position(0)  
+end
+
+def allocate_direct_float_buffer(n)
+  ByteBuffer.allocateDirect(n * java.lang.Float::SIZE/8).order(ByteOrder.nativeOrder).asFloatBuffer
+end