ruby-processing 2.6.3 → 2.6.4

data/samples/contributed/fern.rb

@@ -1,51 +0,0 @@
-# The Fern Fractal
-# by Luis Correia
-
-attr_reader :boundary
-
-def setup
-  size 500, 500
-  @boundary = Boundary.new(0, width )
-  no_loop
-  puts "Be patient. This takes about 10 seconds to render."
-end
-
-def draw
-  background 0
-  load_pixels
-  x0, y0 = 0.0, 0.0
-  x, y, r = 0.0, 0.0, 0.0
-  i, j = 0, 0
-  max_iterations = 200_000
-  max_iterations.times do
-    r = rand(0..100.0)
-    if r <= 1
-      x = 0.0
-      y = 0.16 * y0
-    elsif r <= 7
-      x = 0.2 * x0 - 0.26 * y0
-      y = 0.23 * x0 + 0.22 * y0
-    elsif r <= 14
-      x = -0.15 * x0 + 0.28 * y0
-      y = 0.26 * x0 + 0.24 * y0
-    else
-      x = 0.85 * x0 + 0.04 * y0
-      y = -0.004 * x0 + 0.85 * y0 + 1.6
-    end
-    i = height - (y * 45).to_i
-    j = width / 2 + (x * 45).to_i
-    pixels[i * height + j] += 2_560 if (boundary.include?(i) && boundary.include?(j))
-    x0, y0 = x, y
-  end
-  update_pixels
-end
-
-# Abstract boundary checking to this
-# lightweight class
-#
-
-Boundary = Struct.new(:lower, :upper) do
-  def include? x
-    (lower...upper).cover? x
-  end
-end

data/samples/contributed/fibonacci_sphere.rb

@@ -1,86 +0,0 @@
-# fibonacci_sphere.rb
-# After a vanilla processing sketch by Jim Bumgardner
-# http://www.openprocessing.org/sketch/41142
-#
-# Controls:
-# 1. drag mouse to rotate sphere (uses builtin arcball library)
-# 2. click mouse to toggle add box to sphere surface
-# 3. press x, y, or z to constrain arcball rotation to that axis
-#
-
-load_library :vecmath
-
-PHI = (sqrt(5) + 1) / 2 - 1   # golden ratio
-GA = PHI * TAU           # golden angle
-
-KMAX_POINTS = 100_000
-
-attr_reader :pts, :rotation_x, :rotation_y, :nbr_points, :radius, :add_points
-attr_reader :my_ball # for arcball rotation
-
-def setup
-  size(1024, 768, P3D)
-  ArcBall.init(self, width / 2.0, height / 2.0)
-  @rotation_x = 0
-  @rotation_y = 0
-  @nbr_points = 2000
-  @radius = 0.8 * height / 2
-  @add_points = true
-  @pts = Array.new(KMAX_POINTS)
-  init_sphere(nbr_points)
-  background(0)
-end
-
-def draw    
-  if add_points 
-    @nbr_points += 1
-    @nbr_points = [nbr_points, KMAX_POINTS].min
-    init_sphere(nbr_points)
-  end
-  
-  background 0            
-  lights
-  ambient(200, 10, 10)
-  ambient_light(150, 150, 150)
-  render_globe   
-end
-
-
-###########################################
-# For Fibonacci Sphere
-##################################
-
-def render_globe
-  push_matrix
-  (0..[nbr_points, pts.length].min).each do |i|    
-    lat = pts[i].lat 
-    lon = pts[i].lon    
-    push_matrix
-    rotate_y(lon)
-    rotate_z(-lat)
-    fill(200, 10, 10)
-    translate(radius, 0, 0)
-    box(4, 7, 7)
-    pop_matrix
-  end
-  pop_matrix  
-end
-
-def mouse_clicked
-  @add_points = !add_points
-end
-
-SpherePoint = Struct.new(:lat, :lon)
-
-def init_sphere(num)  
-  (0..num).each do |i| 
-    lon = GA * i
-    lon /= TAU
-    lon -= lon.floor
-    lon *= TAU    
-    lon -= TAU if lon > PI
-    # Convert dome height (which is proportional to surface area) to latitude
-    # lat = asin(-1 + 2 * i / num.to_f)
-    pts[i] = SpherePoint.new(asin(-1 + 2 * i / num.to_f), lon)
-  end
-end

data/samples/contributed/flight_patterns.rb

@@ -1,63 +0,0 @@
-# Description:
-# Flight Patterns is that ol' Euruko 2008 demo.
-# Since processing 2.0 'ovals' don't look too hot
-
-load_libraries 'boids'
-
-def setup
-  size(displayWidth, displayHeight, P3D)
-  sphere_detail 12
-  color_mode RGB, 1.0
-  no_stroke
-  frame_rate 30
-  shininess 1.0
-  specular 0.3, 0.1, 0.1
-  emissive 0.03, 0.03, 0.1
-  
-  @click = false
-  @flocks = []
-  3.times do |i|
-    flock = Boids.flock 20, 0, 0, width, height
-    flock.goal width/2, height/2, 0
-    @flocks << flock
-  end
-end
-
-def mouse_pressed
-  @click = !@click
-end
-
-def draw
-  background 0.05
-  @flocks.each_with_index do |flock, i|
-    flock.goal mouse_x, mouse_y, 0, @flee
-    flock.update(goal: 185, limit: 13.5)
-    for boid in flock do
-      r = 20 + (boid.z * 0.15)      
-      case i
-      when 0 then fill 0.55, 0.35, 0.35
-      when 1 then fill 0.35, 0.55, 0.35
-      when 2 then fill 0.35, 0.35, 0.55
-      end
-      push_matrix
-      translate boid.x-r/2, boid.y-r/2, boid.z-r/2
-      if @click
-        lights_on
-        hint ENABLE_DEPTH_TEST
-        sphere(r/2) 
-      else
-        no_lights
-        hint DISABLE_DEPTH_TEST
-        oval(0, 0, r, r)
-      end
-      pop_matrix
-    end
-  end
-end
-
-def lights_on
-  lights
-  ambient_light 0.01, 0.01, 0.01
-  light_specular 0.4, 0.2, 0.2
-  point_light 1.0, 1.0, 1.0, mouse_x, mouse_y, width / 4.0
-end

data/samples/contributed/full_screen.rb

@@ -1,29 +0,0 @@
-# Description:
-# This is a full-screen demo 
-# Since processing-2.0 it is opengl
-
-class FullScreen < Processing::App  
-  def setup
-    size displayWidth, displayHeight, P3D
-    no_stroke
-  end
-  
-  def draw
-    lights
-    background 0
-    fill 120, 160, 220
-    (width/100).times do |x|
-      (height/100).times do |y|
-        new_x, new_y = x * 100, y * 100
-        push_matrix
-        translate new_x + 50, new_y + 50
-        rotate_y(((mouse_x.to_f + new_x) / width) * Math::PI)
-        rotate_x(((mouse_y.to_f + new_y) / height) * Math::PI)
-        box 90
-        pop_matrix
-      end
-    end
-  end  
-end
-# Full screen should now be set at runtime, now there is only one way to do it!
-FullScreen.new(full_screen: true)

data/samples/contributed/getting_started.rb

@@ -1,24 +0,0 @@
-# Let's define a setup method, for code that gets
-# run one time when the app is started.
-def setup
-  size 200, 200
-  background 0
-  no_stroke
-  smooth
-  @rotation = 0
-end
-
-# And the draw method which will be called repeatedly.
-# Delete this if you don't need animation.
-def draw
-  fill 0, 20
-  rect 0, 0, width, height
-  
-  translate width/2, height/2
-  rotate @rotation
-
-  fill 255
-  ellipse 0, -60, 20, 20
-
-  @rotation += 0.1
-end

data/samples/contributed/grapher.rb

@@ -1,36 +0,0 @@
-# Grapher is based on a context free art design
-# by ColorMeImpressed (takes a bit of time to run)
-# http://www.contextfreeart.org/gallery/view.php?id=2844
-#
-
-load_library :fastmath
-
-CMIN = -2.0 # Important to specify float else get random int from range?
-CMAX = 2.0
-FUZZ = 0.04
-SZ = 5
-
-def setup
-  size 600, 600
-  no_stroke
-  color_mode(HSB, 1.0)
-  background(0)
-  frame_rate(4_000)
-end
-
-def draw
-  translate(width / 2, height / 2)
-  dot(rand(-180..180), rand(-180..180), rand(CMIN..CMAX)) unless frame_count > 200_000
-end
-
-def dot(px, py, c)
-  func = DegLut.sin(px) + DegLut.sin(py) + c
-  # change function to change the graph eg.
-  # func = DegLut.cos(px) + DegLut.sin(py) + c
-  if func.abs <= FUZZ
-    fill(((CMIN - c) / (CMIN - CMAX)), 1, 1)
-    ellipse px * width / 360, py * height / 360, SZ, SZ
-  else
-    dot(rand(-180..180), rand(-180..180), rand(CMIN..CMAX))
-  end
-end

data/samples/contributed/gravity.rb

@@ -1,106 +0,0 @@
-# After Gravity by Christian Hahn
-
-attr_reader :particles, :grabbed
-
-def setup
-  size 600, 500
-  @particles  = []
-  @grabbed    = nil  
-  background 0
-  smooth 4
-  stroke_weight 4
-  ellipse_mode CENTER
-  color_mode RGB, 255
-end
-
-def draw
-  no_stroke
-  fill 0, 60
-  rect 0, 0, width, height
-  particles.each { |p| p.collect_force; p.move; p.render }
-end
-
-def mouse_pressed
-  return if mouse_x == 0 || mouse_y == 0
-  return if particle_grab
-  particles << Particle.new(mouse_x, mouse_y, rand(0.1..8))
-end
-
-def mouse_released
-  @grabbed = nil
-end
-
-def particle_grab
-  @grabbed = particles.detect { |p| dist(mouse_x, mouse_y, p.x1, p.y1) < p.diameter/2 }
-end
-
-class Particle
-  GRAVITY = 1.0  
-  attr_reader :x0, :y0, :x1, :y1, :diameter, :mass_amount
-  
-  def initialize(x, y, mass)
-    @x0, @y0, @x1, @y1  = x, y, x, y
-    @x_speed, @y_speed  = 0, 0
-    @x_accel, @y_accel  = 0, 0
-    @mass_amount        = mass
-    @diameter           = sqrt(mass_amount) * 20
-  end
-  
-  def collect_force
-    @x_accel, @y_accel = 0, 0
-    @min_dist = 1000
-    $app.particles.each do |p|
-      next if p == self
-      g_dist  = Math.hypot(x0 - p.x0, y0 - p.y0)
-      g_theta = -angle_of(x0, y0, p.x0, p.y0)
-      @min_dist = g_dist if g_dist < @min_dist
-      force = (GRAVITY * mass_amount * p.mass_amount) / g_dist
-      if g_dist.abs > diameter
-        @x_accel += force / mass_amount * cos(g_theta)
-        @y_accel += force / mass_amount * sin(g_theta)
-      end
-    end
-  end
-  
-  def move
-    @x_speed, @y_speed = 0, 0 if grabbed?
-    @x_speed += @x_accel
-    @y_speed += @y_accel
-    @x1, @y1 = x0 + @x_speed, y0 + @y_speed
-  end
-  
-  def grabbed?
-    $app.grabbed == self
-  end
-  
-  def render
-    no_stroke
-    grabbed? ? render_grabbed : render_free
-  end
-  
-  def render_free
-    charge_col  = 1000.0 / @min_dist / 50.0
-    tot_col_1   = 100 + charge_col * 6
-    tot_col_2   = 150 + charge_col * charge_col
-    tot_col_3   = diameter + 8 + charge_col
-    fill(tot_col_1, tot_col_1, 255, charge_col * 150 + 3)
-    ellipse(x1, y1, tot_col_3, tot_col_3)
-    fill 0, 255
-    stroke tot_col_2, tot_col_2, 255, charge_col * 255 + 3
-    ellipse x1, y1, diameter, diameter
-    @x0, @y0 = x1, y1
-  end
-  
-  def render_grabbed
-    fill 150, 150, 255, 100
-    ellipse mouse_x, mouse_y, diameter + 8, diameter + 8
-    fill 0, 255
-    stroke 150, 150, 255, 255
-    ellipse mouse_x, mouse_y, diameter, diameter
-    @x0, @y0 = mouse_x, mouse_y
-  end
-  
-  def angle_of(x1, y1, x2, y2)
-    Math::PI - atan2(y1 - y2, x1 - x2)
-  end  
-end

data/samples/contributed/jwishy.rb

@@ -1,95 +0,0 @@
-# This one has a long lineage:
-# It was originally adapted to Shoes in Ruby,
-# from a Python example for Nodebox, and then, now
-# to Ruby-Processing.
-
-# For fun, try running it via jirb, and
-# playing with the attr_accessors, as
-# well as the background.
-
-# This example now demonstrates the use of the control_panel.
-
-# -- omygawshkenas
-
-load_library :control_panel
-
-attr_accessor :x_wiggle, :y_wiggle, :magnitude, :bluish, :panel, :laf, :hide
-
-def setup
-  size 600, 600
-  control_panel do |c|
-    c.look_feel 'Nimbus'
-    c.slider    :bluish, 0.0..1.0, 0.5
-    c.slider    :alpha,  0.0..1.0, 0.5
-    c.checkbox  :go_big
-    c.button    :reset
-    c.menu      :shape, %w(oval square)
-    @panel = c
-  end
-  @hide = false
-  @shape = 'oval'
-  @alpha, @bluish = 0.5, 0.5
-  @x_wiggle, @y_wiggle = 10.0, 0
-  @magnitude = 8.15
-  @background = [0.06, 0.03, 0.18]
-  color_mode RGB, 1
-  ellipse_mode CORNER
-  smooth
-end
-
-def background=(*args)
-  @background = args.flatten
-end
-
-
-def draw_background
-  @background[3] = @alpha
-  fill(*@background) if @background[0]
-  rect 0, 0, width, height
-end
-
-def reset
-  @y_wiggle = 0
-end
-
-def draw
-  # only make control_panel visible once, or again when hide is false
-  unless hide
-    @hide = true
-    panel.set_visible(hide)
-  end
-  draw_background
-
-  # Seed the random numbers for consistent placement from frame to frame
-  srand(0)
-  horiz, vert, mag = @x_wiggle, @y_wiggle, @magnitude
-
-  if @go_big
-    mag  *= 2
-    vert /= 2
-  end
-
-  blu = bluish
-  x, y = (width / 2), -27
-  c = 0.0
-
-  64.times do
-    x += cos(horiz) * mag
-    y += log10(vert) * mag + sin(vert) * 2
-    fill(sin(@y_wiggle + c), rand * 0.2, rand * blu, 0.5)
-    s = 42 + cos(vert) * 17
-    args = [x - s / 2, y - s / 2, s, s]
-    @shape == 'oval' ? oval(*args) : rect(*args)
-    vert += rand * 0.25
-    horiz += rand * 0.25
-    c += 0.1
-  end
-
-  @x_wiggle += 0.05
-  @y_wiggle += 0.1
-end
-
-def mouse_pressed
-  @hide = false if hide
-end
-