ruby-processing 2.6.3 → 2.6.4

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

@@ -1,32 +0,0 @@
-#
-# 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: #{format('%0.2f', frame_rate)}"     
-end
-

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

@@ -1,28 +0,0 @@
-##
-# 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 = load_shader('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

@@ -1,18 +0,0 @@
-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

@@ -1,64 +0,0 @@
-#
-# 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

@@ -1,43 +0,0 @@
-#
-# 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

@@ -1 +0,0 @@
-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,80 +0,0 @@
-#
-# 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.
-#
-load_libraries :control_panel
-
-attr_reader :gravity, :panel
-
-def setup
-  size 640, 340  
-  fill 0
-  
-  # Control panel for changing gravity
-  control_panel do |c|
-    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, gravity)
-  display(@s1, mouse_x, mouse_y)
-  
-  @s2.update(@s1.x, @s1.y, gravity)
-  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
-  include Processing::Proxy
-  
-  attr_reader :x, :y, :gravity
-  
-  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
-    @stiffness = 0.2
-    @damping   = 0.7
-  end
-  
-  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 += gravity
-    ay = force_y / @mass
-    @vy = @damping * (@vy + ay)
-    @y += @vy
-  end
-  
-  def diameter
-    @radius * 2
-  end
-  
-end

data/samples/processing_app/topics/simulate/data/java_args.txt

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

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

@@ -1,32 +0,0 @@
-#
-# Flocking
-# by Daniel Shiffman.
-#
-# An implementation of Craig Reynold's Boids program to simulate
-# the flocking behavior of birds. Each boid steers itself based on
-# rules of avoidance, alignment, and coherence.
-#
-# Click the mouse to add a new boid.
-#
-load_libraries :flock, :vecmath
-
-attr_reader :flock
-
-def setup
-  size(640, 360)
-  @flock = Flock.new
-  # Add an initial set of boids into the system
-  150.times do
-    flock << Boid.new(width / 2, height / 2)
-  end
-end
-
-def draw
-  background(50)
-  flock.run
-end
-
-# Add a new boid into the System
-def mouse_pressed
-  flock << Boid.new(mouse_x, mouse_y)
-end

data/samples/processing_app/topics/simulate/library/flock/flock.rb

@@ -1,203 +0,0 @@
-# The Flock (a list of Boid objects)
-require 'forwardable'
-
-class Flock
-  include Enumerable
-  extend Forwardable
-  def_delegators(:@boids, :<<, :each)
-
-  attr_reader :boids
-
-  def initialize
-    @boids = []
-  end
-
-  def run
-    each do |bird|
-      bird.run(self)  # Passing the entire list of boids to each boid individually
-    end
-  end
-end
-
-# The Boid class
-
-class Boid
-  include Processing::Proxy
-
-  MAXSPEED = 2
-  MAXFORCE = 0.03
-
-  attr_reader :width, :height
-  attr_reader :location, :velocity, :acceleration, :sz
-
-  def initialize(x, y)
-    @width, @height = $app.width, $app.height
-    @acceleration = Vec2D.new(0, 0)
-    @velocity = Vec2D.new(rand(-1.0..1), rand(-1.0..1))
-    @location = Vec2D.new(x, y)
-    @sz = 4.0
-  end
-
-  def run(boids)
-    flock(boids)
-    update
-    borders
-    render
-  end
-
-  def apply_force(force)
-    # We could add mass here if we want A = F / M
-    @acceleration += force
-  end
-
-  # We accumulate a new acceleration each time based on three rules
-  def flock boids
-    sep = separate(boids)   # Separation
-    ali = align(boids)      # Alignment
-    coh = cohesion(boids)   # Cohesion
-    # Arbitrarily weight these forces
-    sep *= 1.5
-    ali *= 1.0
-    coh *= 1.0
-    # Add the force vectors to acceleration
-    apply_force(sep)
-    apply_force(ali)
-    apply_force(coh)
-  end
-
-  # Method to update location
-  def update
-    # Update velocity
-    @velocity += acceleration
-    # Limit speed
-    velocity.set_mag(MAXSPEED) {velocity.mag > MAXSPEED}
-    @location += velocity
-    # Reset accelertion to 0 each cycle
-    @acceleration *= 0
-  end
-
-  # A method that calculates and applies a steering force towards a target
-  # STEER = DESIRED MINUS VELOCITY
-  def seek(target)
-    desired = target - location  # A vector pointing from the location to the target
-    # Normalize desired and scale to maximum speed
-    desired.normalize!
-    desired *= MAXSPEED
-    # Steering = Desired minus Velocity
-    steer = desired - velocity
-    steer.set_mag(MAXFORCE) {steer.mag > MAXFORCE} # Limit to maximum steering force
-    steer
-  end
-
-  def render
-    # Draw a triangle rotated in the direction of velocity
-    theta = velocity.heading + 90.radians
-    fill(200,100)
-    stroke(255)
-    push_matrix
-    translate(location.x,location.y)
-    rotate(theta)
-    begin_shape(TRIANGLES)
-    vertex(0, -sz)
-    vertex(-sz * 0.5, sz)
-    vertex(sz * 0.5, sz)
-    end_shape
-    pop_matrix
-  end
-
-  # Wraparound
-  def borders
-    if (location.x < -sz * 0.5)
-      location.x = width + sz * 0.5
-    end
-    if (location.y < -sz * 0.5)
-      location.y = height + sz * 0.5
-    end
-    if (location.x >  width + sz * 0.5)
-      location.x = -sz
-    end
-    if (location.y > height + sz * 0.5)
-      location.y = -sz * 0.5
-    end
-  end
-
-  # Separation
-  # Method checks for nearby boids and steers away
-  def separate boids
-    desiredseparation = 25.0
-    steer = Vec2D.new
-    count = 0
-    # For every boid in the system, check if it's too close
-    boids.each do |other|
-      d = location.dist(other.location)
-      # If the distance is greater than 0 and less than an arbitrary amount (0 when you are yourself)
-      if ((d > 0) && (d < desiredseparation))
-        # Calculate vector pointing away from neighbor
-        diff = location - other.location
-        diff.normalize!
-        diff /= d             # Weight by distance
-        steer += diff
-        count += 1            # Keep track of how many
-      end
-    end
-    # Average -- divide by how many
-    if (count > 0)
-      steer /= count.to_f
-    end
-
-    # As long as the vector is greater than 0
-    if (steer.mag > 0)
-      # Implement Reynolds: Steering = Desired - Velocity
-      steer.normalize!
-      steer *= MAXSPEED
-      steer -= velocity
-      steer.set_mag(MAXFORCE) {steer.mag > MAXFORCE}
-    end
-    return steer
-  end
-
-  # Alignment
-  # For every nearby boid in the system, calculate the average velocity
-  def align boids
-    neighbordist = 50
-    sum = Vec2D.new(0, 0)
-    count = 0
-    boids.each do |other|
-      d = location.dist(other.location)
-      if ((d > 0) && (d < neighbordist))
-        sum += other.velocity
-        count += 1
-      end
-    end
-    if (count > 0)
-      sum /= (count.to_f)
-      sum.normalize!
-      sum *= MAXSPEED
-      steer = sum - velocity
-      steer.set_mag(MAXFORCE) {steer.mag > MAXFORCE}
-      return steer
-    else
-      return Vec2D.new
-    end
-  end
-
-  # Cohesion
-  # For the average location (i.e. center) of all nearby boids, calculate steering vector towards that location
-  def cohesion boids
-    neighbordist = 50
-    sum = Vec2D.new   # Start with empty vector to accumulate all locations
-    count = 0
-    boids.each do |other|
-      d = location.dist(other.location)
-      if ((d > 0) && (d < neighbordist))
-        sum += other.location # Add location
-        count += 1
-      end
-    end
-    sum /= count unless (count == 0)        # avoid div by zero
-    return (count > 0)? seek(sum) : Vec2D.new
-  end
-end
-
-
-