ruby-processing 2.4.4 → 2.5.0

data/samples/processing_app/topics/shaders/deform.rb

@@ -14,15 +14,15 @@ def setup
   size(640, 360, P2D)
   
   textureWrap(REPEAT)
-  @tex = loadImage("tex1.jpg")
+  @tex = loadImage('tex1.jpg')
  
-  @deform = loadShader("deform.glsl")
-  deform.set("resolution", width.to_f, height.to_f)
+  @deform = loadShader('deform.glsl')
+  deform.set('resolution', width.to_f, height.to_f)
 end
 
 def draw
-  deform.set("time", millis / 1000.0)
-  deform.set("mouse", mouse_x.to_f, mouse_y.to_f)
+  deform.set('time', millis / 1000.0)
+  deform.set('mouse', mouse_x.to_f, mouse_y.to_f)
   shader(deform)
   image(tex, 0, 0, width, height)
 end

data/samples/processing_app/topics/shaders/edge_detect.rb

@@ -11,14 +11,12 @@ attr_reader :edges, :img , :enabled
 def setup
   size(640, 360, P2D)
   @enabled = true
-  @img = load_image("leaves.jpg");      
-  @edges = load_shader("edges.glsl")
+  @img = load_image('leaves.jpg');      
+  @edges = load_shader('edges.glsl')
 end
 
 def draw
-  if (enabled == true)
-    shader(edges)
-  end
+  shader(edges) if enabled
   image(img, 0, 0)
 end
 

data/samples/processing_app/topics/shaders/glossy_fish_eye.rb

@@ -9,22 +9,20 @@
 attr_reader :ball, :canvas, :glossy, :fisheye, :img, :use_fish_eye
 
 def setup
-  size(640, 640, P3D)  
+  size(640, 640, P3D)
   @canvas = create_graphics(width, height, P3D)
   @use_fish_eye = true
-  @fisheye = load_shader("FishEye.glsl")
-  fisheye.set("aperture", 180.0)
-  
-  @glossy = load_shader("GlossyFrag.glsl", "GlossyVert.glsl")  
-  glossy.set("AmbientColour", 0.0, 0.0, 0.0)
-  glossy.set("DiffuseColour", 0.9, 0.2, 0.2)
-  glossy.set("SpecularColour", 1.0, 1.0, 1.0)
-  glossy.set("AmbientIntensity", 1.0)
-  glossy.set("DiffuseIntensity", 1.0)
-  glossy.set("SpecularIntensity", 0.7)
-  glossy.set("Roughness", 0.7)
-  glossy.set("Sharpness", 0.0)
-  
+  @fisheye = load_shader('FishEye.glsl')
+  fisheye.set('aperture', 180.0)
+  @glossy = load_shader('GlossyFrag.glsl', 'GlossyVert.glsl')  
+  glossy.set('AmbientColour', 0.0, 0.0, 0.0)
+  glossy.set('DiffuseColour', 0.9, 0.2, 0.2)
+  glossy.set('SpecularColour', 1.0, 1.0, 1.0)
+  glossy.set('AmbientIntensity', 1.0)
+  glossy.set('DiffuseIntensity', 1.0)
+  glossy.set('SpecularIntensity', 0.7)
+  glossy.set('Roughness', 0.7)
+  glossy.set('Sharpness', 0.0)
   @ball = create_shape(SPHERE, 50)
   ball.set_stroke(false)
 end
@@ -53,11 +51,7 @@ def draw
   image(canvas, 0, 0, width, height)
 end
 
-def mousePressed
-  if (use_fish_eye)
-    @use_fish_eye = false
-    reset_shader    
-  else
-    @use_fish_eye = true
-  end
+def mouse_pressed
+  @use_fish_eye = !use_fish_eye
+  reset_shader    
 end

data/samples/processing_app/topics/shaders/glsl_heightmap_noise.rb

@@ -7,7 +7,7 @@
 # 
 # c = cycle through the color maps
 # 
-# Tested with Processing 2.0.1 Final
+# Tested with ruby-procesing 2.5.0
 # 
 # Photographs by Folkert Gorter (@folkertgorter / http://superfamous.com/) made available under a CC Attribution 3.0 license.
 #
@@ -25,46 +25,47 @@ attr_reader :displace # GLSL shader
 attr_reader :images # array to hold 2 input images
 attr_reader :current_color_map # variable to keep track of the current colorMap
 
+
 def setup
   size(1280, 720, P3D) # use the P3D OpenGL renderer
-  @blur_factor = 3 
-  @resize_factor = 0.25 
+  
+  @blur_factor = 3
+  @resize_factor = 0.25
   displace_strength = 0.25 # the displace strength of the GLSL shader displacement effect
   # load the images from the _Images folder (relative path from this sketch's folder)
   @images = []  
-  images << load_image(data_path("Texture01.jpg"))
-  images << load_image(data_path("Texture02.jpg"))
+  images << load_image(data_path('Texture01.jpg'))
+  images << load_image(data_path('Texture02.jpg'))
   @current_color_map = 0
   # load the PShader with a fragment and a vertex shader
-  @displace = load_shader("displaceFrag.glsl", "displaceVert.glsl") 
-  displace.set("displaceStrength", displace_strength) # set the displace_strength
-  displace.set("colorMap", images[current_color_map]) # set the initial colorMap
+  @displace = load_shader('displaceFrag.glsl', 'displaceVert.glsl') 
+  displace.set('displaceStrength', displace_strength) # set the displace_strength
+  displace.set('colorMap', images[current_color_map]) # set the initial colorMap
   # create the heightmap PShape (see custom creation method) and put it in the global height_map reference
   @height_map = create_plane(DIM, DIM)
 end
 
 def draw
-  pointLight(255, 255, 255, 2*(mouse_x - width / 2), 2*(mouse_y - height / 2), 500) # required for texLight shader
-
+  # required for texLight shader
+  pointLight(255, 255, 255, 2 * (mouse_x - width / 2), 2 * (mouse_y - height / 2), 500)
   translate(width / 2, height / 2)   # translate to center of the screen
   rotate_x(radians(60))          # fixed rotation of 60 degrees over the X axis
-  rotate_z(frame_count*0.005)    # dynamic frameCount-based rotation over the Z axis
+  rotate_z(frame_count * 0.005)  # dynamic frameCount-based rotation over the Z axis
 
   background(0) # black background
   perspective(PI/3.0, width.to_f / height, 0.1, 1000000) # perspective for close shapes
   scale(750) # scale by 750 (the model itself is unit length
 
-  displace.set("time", millis() / 5000.0) # feed time to the GLSL shader
+  displace.set('time', millis / 5000.0) # feed time to the GLSL shader
   shader(displace)                        # use shader
   shape(height_map)                       # display the PShape
 
   # write the fps and the current colorMap in the top-left of the window
-  frame.set_title("FrameRate: #{frame_rate.to_i} | colorMap: #{current_color_map}")
+  frame.set_title('FrameRate: #{frame_rate.to_i} | colorMap: #{current_color_map + 1}')
 end
 
 # custom method to create a PShape plane with certain xy DIMensions
-def create_plane(xsegs, ysegs) 
-
+def create_plane(xsegs, ysegs)
   # STEP 1: create all the relevant data
   
   @positions = [] # arrayList to hold positions
@@ -95,16 +96,17 @@ def create_plane(xsegs, ysegs)
   # STEP 2: put all the relevant data into the PShape
 
   texture_mode(NORMAL) # set texture_mode to normalized (range 0 to 1)
-  tex = load_image(data_path "Texture01.jpg")
+  tex = load_image(data_path 'Texture01.jpg')
   
   mesh = create_shape # create the initial PShape
+  renderer = ShapeRender.new(mesh) # initialize the shape renderer
   mesh.begin_shape(QUADS) # define the PShape type: QUADS
   mesh.no_stroke
   mesh.texture(tex) # set a texture to make a textured PShape
   # put all the vertices, uv texture coordinates and normals into the PShape
   positions.each_with_index { |p, i|
     t = tex_coords[i]
-    mesh.vertex(p.x, p.y, p.z, t.x, t.y)
+    p.to_vertex_uv(renderer, t.x, t.y)
   }
   mesh.end_shape
 
@@ -115,9 +117,9 @@ def key_pressed
   case key
   when '1', '2'
     @current_color_map = key.to_i % 2 #images.size
-    displace.set("colorMap", images[current_color_map]) 
+    displace.set('colorMap', images[current_color_map]) 
   else
-    puts "key pressed: #{key}"
+    puts 'key pressed: #{key}'
   end # cycle through colorMaps (set variable and set colorMap in PShader)
 end
 

data/samples/processing_app/topics/shaders/image_mask.rb

@@ -8,24 +8,24 @@ attr_reader :mask_shader, :src_image, :mask_image
 
 def setup
   size(640, 360, P2D)
-  @src_image = load_image("leaves.jpg")
+  @src_image = load_image('leaves.jpg')
   @mask_image = create_graphics(src_image.width, src_image.height, P2D)
   mask_image.no_smooth
-  @mask_shader = load_shader("mask.glsl")
-  mask_shader.set("mask", mask_image)
+  @mask_shader = load_shader('mask.glsl')
+  mask_shader.set('mask', mask_image)
   background(255)
 end
 
-def draw 
+def draw
   mask_image.begin_draw
   mask_image.background(0)
-  if (mouse_x != 0 && mouse_y != 0) 
+  if (mouse_x != 0) && (mouse_y != 0)
     mask_image.no_stroke
     mask_image.fill(255, 0, 0)
     mask_image.ellipse(mouse_x, mouse_y, 50, 50)
   end
   mask_image.end_draw
-  shader(mask_shader)    
+  shader(mask_shader)
   image(src_image, 0, 0, width, height)
 end
 

data/samples/processing_app/topics/shaders/landscape.rb

@@ -16,17 +16,17 @@ def setup
    
   # The code of this shader shows how to integrate shaders from shadertoy
   # into Processing with minimal changes.
-  @landscape = load_shader("landscape.glsl")
-  landscape.set("resolution", width.to_f, height.to_f)  
+  @landscape = load_shader('landscape.glsl')
+  landscape.set('resolution', width.to_f, height.to_f)  
 end
 
 def draw
   background_int 0
     
-  landscape.set("time", (millis/1000.0).to_f)
+  landscape.set('time', (millis/1000.0).to_f)
   shader(landscape) 
   rect(0, 0, width, height)
 
-  frame.set_title "frame: #{frame_count} - fps: #{format("%.2f", frame_rate)}"     
+  frame.set_title 'frame: #{frame_count} - fps: #{format('%.2f', frame_rate)}'     
 end
 

data/samples/processing_app/topics/shaders/monjori.rb

@@ -1,28 +1,28 @@
 ##
- # Monjori. 
- # 
- # GLSL version of the 1k intro Monjori from the demoscene 
- # (http://www.pouet.net/prod.php?which=52761)
- # Ported from the webGL version available in ShaderToy:
- # http://www.iquilezles.org/apps/shadertoy/
- # (Look for Monjori under the Plane Deformations Presets) 
-##
+# Monjori. 
+# 
+# GLSL version of the 1k intro Monjori from the demoscene 
+# (http://www.pouet.net/prod.php?which=52761)
+# Ported from the webGL version available in ShaderToy:
+# http://www.iquilezles.org/apps/shadertoy/
+# (Look for Monjori under the Plane Deformations Presets) 
+
  
 attr_reader :monjori
 
 def setup
   size(640, 360, P2D)
-  no_stroke 
-  @monjori = loadShader("monjori.glsl")
-  monjori.set("resolution", width.to_f, height.to_f)   
+  no_stroke
+  @monjori = load_shader('monjori.glsl')
+  monjori.set('resolution', width.to_f, height.to_f)
 end
 
 def draw
-  monjori.set("time", millis() / 1000.0)  
+  monjori.set('time', millis / 1000.0)
   shader(monjori)
   # This kind of effects are entirely implemented in the
-  # fragment shader, they only need a quad covering the  
+  # fragment shader, they only need a quad covering the
   # entire view area so every pixel is pushed through the 
-  # shader.   
-  rect(0, 0, width, height)  
+  # shader.
+  rect(0, 0, width, height)
 end

data/samples/processing_app/topics/shaders/nebula.rb

@@ -2,12 +2,12 @@ attr_reader :nebula
 
 def setup
   size(512, 384, P2D)
-  @nebula = load_shader("nebula.glsl")
-  nebula.set("resolution", width.to_f, height.to_f) 
+  @nebula = load_shader('nebula.glsl')
+  nebula.set('resolution', width.to_f, height.to_f) 
 end
 
 def draw
-  nebula.set("time", millis() / 1000.0)
+  nebula.set('time', millis / 1000.0)
   shader(nebula)
   # The rect is needed to make the fragment shader go through every pixel of
   # the screen, but is not used for anything else since the rendering is entirely

data/samples/processing_app/topics/shaders/sep_blur.rb

@@ -10,9 +10,9 @@ attr_reader :blur, :src, :pass1, :pass2
 
 def setup
   size(640, 360, P2D)  
-  @blur = load_shader("sep_blur.glsl")
-  blur.set("blurSize", 9)
-  blur.set("sigma", 5.0)  
+  @blur = load_shader('sep_blur.glsl')
+  blur.set('blurSize', 9)
+  blur.set('sigma', 5.0)  
   @src = create_graphics(width, height, P2D)  
   @pass1 = create_graphics(width, height, P2D)
   pass1.no_smooth  
@@ -28,14 +28,14 @@ def draw
   src.end_draw
   
   # Applying the blur shader along the vertical direction   
-  blur.set("horizontalPass", 0)
+  blur.set('horizontalPass', 0)
   pass1.begin_draw            
   pass1.shader(blur)  
   pass1.image(src, 0, 0)
   pass1.end_draw
   
   # Applying the blur shader along the horizontal direction      
-  blur.set("horizontalPass", 1)
+  blur.set('horizontalPass', 1)
   pass2.begin_draw            
   pass2.shader(blur)  
   pass2.image(pass1, 0, 0)
@@ -46,19 +46,19 @@ end
 def key_pressed
   case(key)
   when '9'
-    blur.set("blurSize", 9)
-    blur.set("sigma", 5.0)
+    blur.set('blurSize', 9)
+    blur.set('sigma', 5.0)
   when '7'
-    blur.set("blurSize", 7)
-    blur.set("sigma", 3.0)
+    blur.set('blurSize', 7)
+    blur.set('sigma', 3.0)
   when '5' 
-    blur.set("blurSize", 5)
-    blur.set("sigma", 2.0)  
+    blur.set('blurSize', 5)
+    blur.set('sigma', 2.0)  
   when '3'
-    blur.set("blurSize", 5)
-    blur.set("sigma", 1.0)  
+    blur.set('blurSize', 5)
+    blur.set('sigma', 1.0)  
   else
-    blur.set("blurSize", 9)
-    blur.set("sigma", 5.0)
+    blur.set('blurSize', 9)
+    blur.set('sigma', 5.0)
   end  
 end 

data/samples/processing_app/topics/shaders/toon_shading.rb

@@ -2,7 +2,7 @@
 # Toon Shading.
 # 
 # Example showing the use of a custom lighting shader in order  
-# to apply a "toon" effect on the scene. Based on the glsl tutorial 
+# to apply a 'toon' effect on the scene. Based on the glsl tutorial 
 # from lighthouse 3D:
 # http://www.lighthouse3d.com/tutorials/glsl-tutorial/toon-shader-version-ii/
 #
@@ -14,7 +14,7 @@ def setup
   @shader_enabled = true  
   no_stroke
   fill(204)
-  @toon = load_shader("ToonFrag.glsl", "ToonVert.glsl")
+  @toon = load_shader('ToonFrag.glsl', 'ToonVert.glsl')
 end
 
 def draw

data/samples/processing_app/topics/simulate/chain.rb

@@ -12,26 +12,26 @@ def setup
   size 640, 340  
   fill 0
   
-  # Inputs: spring1, spring2, mass, gravity
-  @gravity = 6.0
-  @mass    = 2.0
-  @s1      = Spring2d.new(width/2, height/2, @mass)
-  @s2      = Spring2d.new(width/2, height/2, @mass)
-  
   # Control panel for changing gravity
   control_panel do |c|
-    c.slider :gravity, 0..30
+    c.slider :gravity, 0..30, 6
     @panel = c
   end
+  
+  @mass    = 2.0
+  @s1      = Spring2d.new(width/2, height/2, @mass, gravity)
+  @s2      = Spring2d.new(width/2, height/2, @mass, gravity)
+  
+
 end
 
 def draw
   panel.set_visible(true) if self.visible
   background 204
-  @s1.update(mouse_x, mouse_y)
+  @s1.update(mouse_x, mouse_y, gravity)
   display(@s1, mouse_x, mouse_y)
   
-  @s2.update(@s1.x, @s1.y)
+  @s2.update(@s1.x, @s1.y, gravity)
   display(@s2, @s1.x, @s1.y)
 end
 
@@ -45,12 +45,14 @@ end
 
 
 class Spring2d
+  include Processing::Proxy
   
-  attr_reader :x, :y
+  attr_reader :x, :y, :gravity
   
-  def initialize(xpos, ypos, mass)
+  def initialize(xpos, ypos, mass, gravity)
     @x         = xpos # The x-coordinate
     @y         = ypos # The y-coordinate
+    @gravity   = gravity
     @mass      = mass
     @vx, @vy   = 0, 0 # The x- and y-axis velocities
     @radius    = 20
@@ -58,14 +60,14 @@ class Spring2d
     @damping   = 0.7
   end
   
-  def update(target_x, target_y)
+  def update(target_x, target_y, gravity)
     force_x = (target_x - self.x) * @stiffness
     ax = force_x / @mass
     @vx = @damping * (@vx + ax)
     @x += @vx
-    
+    @gravity = gravity
     force_y = (target_y - self.y) * @stiffness
-    force_y += $app.gravity
+    force_y += gravity
     ay = force_y / @mass
     @vy = @damping * (@vy + ay)
     @y += @vy