ruby-processing 1.0.11 → 2.4.1

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

@@ -0,0 +1,122 @@
+#
+# Noise-Based GLSL Heightmap by Amnon Owed (May 2013)
+# https://github.com/AmnonOwed
+# http://vimeo.com/amnon
+# 
+# Creating a GLSL heightmap running on shader-based procedural noise.
+# 
+# c = cycle through the color maps
+# 
+# Tested with Processing 2.0.1 Final
+# 
+# Photographs by Folkert Gorter (@folkertgorter / http://superfamous.com/) made available under a CC Attribution 3.0 license.
+#
+
+DIM = 300 # the grid dimensions of the heightmap
+attr_reader :blur_factor # the blur for the displacement map (to make it smoother)
+attr_reader :resize_factor # the resize factor for the displacement map (to make it smoother)
+attr_reader :displace_strength 
+attr_reader :positions 
+attr_reader :tex_coords 
+attr_reader :height_map # PShape to hold the geometry, textures, texture coordinates etc.
+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 
+  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"))
+  @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
+  # 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
+
+  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
+
+  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
+  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}")
+end
+
+# custom method to create a PShape plane with certain xy DIMensions
+def create_plane(xsegs, ysegs) 
+
+  # STEP 1: create all the relevant data
+  
+  @positions = [] # arrayList to hold positions
+  @tex_coords = [] # arrayList to hold texture coordinates
+
+  usegsize = 1 / xsegs.to_f # horizontal stepsize
+  vsegsize = 1 / ysegs.to_f # vertical stepsize
+
+  xsegs.times do |x|
+    ysegs.times do |y|
+      u = x / xsegs.to_f
+      v = y / ysegs.to_f
+
+      # generate positions for the vertices of each cell (-0.5 to center the shape around the origin)
+      positions << PVector.new(u - 0.5, v - 0.5, 0)
+      positions << PVector.new(u + usegsize - 0.5, v - 0.5, 0)
+      positions << PVector.new(u + usegsize - 0.5, v + vsegsize - 0.5, 0)
+      positions << PVector.new(u - 0.5, v +  vsegsize - 0.5, 0)
+
+      # generate texture coordinates for the vertices of each cell
+      tex_coords << PVector.new(u, v)
+      tex_coords << PVector.new(u + usegsize, v)
+      tex_coords << PVector.new(u + usegsize, v + vsegsize)
+      tex_coords << PVector.new(u, v + vsegsize)
+    end
+  end
+
+  # 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")
+  
+  mesh = create_shape # create the initial PShape
+  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)
+  }
+  mesh.end_shape
+
+  return mesh # our work is done here, return DA MESH! -)
+end
+
+def key_pressed
+  case key
+  when '1', '2'
+    @current_color_map = key.to_i % 2 #images.size
+    displace.set("colorMap", images[current_color_map]) 
+  else
+    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

@@ -0,0 +1,31 @@
+#
+# Image Mask
+# 
+# Move the mouse to reveal the image through the dynamic mask.
+#
+ 
+attr_reader :mask_shader, :src_image, :mask_image
+
+def setup
+  size(640, 360, P2D)
+  @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)
+  background(255)
+end
+
+def draw 
+  mask_image.begin_draw
+  mask_image.background(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)    
+  image(src_image, 0, 0, width, height)
+end
+

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

@@ -0,0 +1,32 @@
+#
+# Elevated
+# https://www.shadertoy.com/view/MdX3Rr by inigo quilez
+# Created by inigo quilez - iq/2013
+# License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
+# Processing port by Raphaël de Courville.
+#
+ 
+attr_reader :landscape
+
+java_alias :background_int, :background, [Java::int]
+
+def setup
+  size(640, 360, P2D)
+  no_stroke
+   
+  # 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)  
+end
+
+def draw
+  background_int 0
+    
+  landscape.set("time", (millis/1000.0).to_f)
+  shader(landscape) 
+  rect(0, 0, width, height)
+
+  frame.set_title "frame: #{frame_count} - fps: #{frame_rate}"     
+end
+

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

@@ -0,0 +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) 
+##
+ 
+attr_reader :monjori
+
+def setup
+  size(640, 360, P2D)
+  no_stroke 
+  @monjori = loadShader("monjori.glsl")
+  monjori.set("resolution", width.to_f, height.to_f)   
+end
+
+def draw
+  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  
+  # entire view area so every pixel is pushed through the 
+  # shader.   
+  rect(0, 0, width, height)  
+end

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

@@ -0,0 +1,18 @@
+attr_reader :nebula
+
+def setup
+  size(512, 384, P2D)
+  @nebula = load_shader("nebula.glsl")
+  nebula.set("resolution", width.to_f, height.to_f) 
+end
+
+def draw
+  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
+  # generated by the shader.
+  no_stroke
+  fill(0)
+  rect(0, 0, width, height)  
+end

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

@@ -0,0 +1,64 @@
+#
+# Separate Blur Shader
+# 
+# This blur shader works by applying two successive passes, one horizontal
+# and the other vertical.
+# 
+#
+
+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)  
+  @src = create_graphics(width, height, P2D)  
+  @pass1 = create_graphics(width, height, P2D)
+  pass1.no_smooth  
+  @pass2 = create_graphics(width, height, P2D)
+  pass2.no_smooth
+end
+
+def draw
+  src.begin_draw
+  src.background(0)
+  src.fill(255)
+  src.ellipse(width/2, height/2, 150, 150)
+  src.end_draw
+  
+  # Applying the blur shader along the vertical direction   
+  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)
+  pass2.begin_draw            
+  pass2.shader(blur)  
+  pass2.image(pass1, 0, 0)
+  pass2.end_draw  
+  image(pass2, 0, 0)   
+end
+
+def key_pressed
+  case(key)
+  when '9'
+    blur.set("blurSize", 9)
+    blur.set("sigma", 5.0)
+  when '7'
+    blur.set("blurSize", 7)
+    blur.set("sigma", 3.0)
+  when '5' 
+    blur.set("blurSize", 5)
+    blur.set("sigma", 2.0)  
+  when '3'
+    blur.set("blurSize", 5)
+    blur.set("sigma", 1.0)  
+  else
+    blur.set("blurSize", 9)
+    blur.set("sigma", 5.0)
+  end  
+end 

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

@@ -0,0 +1,43 @@
+#
+# 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 
+# from lighthouse 3D:
+# http://www.lighthouse3d.com/tutorials/glsl-tutorial/toon-shader-version-ii/
+#
+
+attr_reader :toon, :shader_enabled
+
+def setup
+  size(640, 360, P3D)
+  @shader_enabled = true  
+  no_stroke
+  fill(204)
+  @toon = load_shader("ToonFrag.glsl", "ToonVert.glsl")
+end
+
+def draw
+  if (shader_enabled == true)
+    shader(toon)
+  end
+  
+  no_stroke 
+  background(0) 
+  dir_y = (mouse_y / height.to_f - 0.5) * 2
+  dir_x = (mouse_x / width.to_f - 0.5) * 2
+  directional_light(204, 204, 204, -dir_x, -dir_y, -1)
+  translate(width/2, height/2)
+  sphere(120)
+end  
+
+def mouse_pressed
+  if (shader_enabled)
+    @shader_enabled = false
+    reset_shader
+    
+  else
+    @shader_enabled = true
+  end
+end
+

data/samples/processing_app/topics/simulate/README

@@ -0,0 +1 @@
+Some sketches in this folder may ned to be run with the --nojruby flag, eg smok_particle_system.rb. 

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

@@ -1,51 +1,49 @@
-require 'ruby-processing'
-
 #
 # Ported from http://processing.org/learning/topics/chain.html
 #
 # One mass is attached to the mouse position and the other is attached the position of the other mass. 
 # The gravity in the environment pulls down on both.
 #
-class Chain < Processing::App
+load_libraries :control_panel
+
+attr_reader :gravity, :panel
+
+def setup
+  size 640, 340  
+  fill 0
   
-  attr_reader :gravity
+  # 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)
   
-  load_library :control_panel
-
-  def setup
-    smooth
-    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
-    end
+  # Control panel for changing gravity
+  control_panel do |c|
+    c.slider :gravity, 0..30
+    @panel = c
   end
-  
-  def draw
-    background 204
-    @s1.update(mouse_x, mouse_y)
-    display(@s1, mouse_x, mouse_y)
+end
 
-    @s2.update(@s1.x, @s1.y)
-    display(@s2, @s1.x, @s1.y)
-  end
+def draw
+  panel.set_visible(true) if self.visible
+  background 204
+  @s1.update(mouse_x, mouse_y)
+  display(@s1, mouse_x, mouse_y)
   
-  def display(spring, nx, ny)
-    no_stroke
-    ellipse(spring.x, spring.y, spring.diameter, spring.diameter)
-    stroke 255
-    line(spring.x, spring.y, nx, ny)
-  end
+  @s2.update(@s1.x, @s1.y)
+  display(@s2, @s1.x, @s1.y)
+end
 
+def display(spring, nx, ny)
+  no_stroke
+  ellipse(spring.x, spring.y, spring.diameter, spring.diameter)
+  stroke 255
+  line(spring.x, spring.y, nx, ny)
 end
 
+
+
 class Spring2d
   
   attr_reader :x, :y
@@ -59,7 +57,7 @@ class Spring2d
     @stiffness = 0.2
     @damping   = 0.7
   end
-
+  
   def update(target_x, target_y)
     force_x = (target_x - self.x) * @stiffness
     ax = force_x / @mass
@@ -77,6 +75,4 @@ class Spring2d
     @radius * 2
   end
   
-end
-
-Chain.new(:width => 200, :height => 200, :title => "Chain", :full_screen => false)
+end