ruby-processing 1.0.11 → 2.4.1

data/samples/external_library/java_processing/toxiclibs/gray_scott_image.rb

@@ -0,0 +1,79 @@
+#
+# <p>GrayScottImage uses the seedImage() method to use a bitmap as simulation seed.
+# In this demo the image is re-applied every frame and the user can adjust the 
+# F coefficient of the reaction diffusion to produce different patterns emerging
+# from the boundary of the bitmapped seed. Unlike some other GS demos provided,
+# this one also uses a wrapped simulation space, creating tiled patterns.</p>
+#
+# <p><strong>usage:</strong></p>
+# <ul>
+# <li>click + drag mouse to locally disturb the simulation</li>
+# <li>press 1-9 to adjust the F parameter of the simulation</li> 
+# <li>press any other key to reset</li>
+# </ul>
+#
+
+# 
+# Copyright (c) 2010 Karsten Schmidt
+# 
+# This demo & library is free software you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation either
+# version 2.1 of the License, or (at your option) any later version.
+# 
+# http:#creativecommons.org/licenses/LGPL/2.1/
+# 
+# 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+load_libraries 'simutils','toxiclibscore','colorutils'
+
+module Toxi
+  include_package "toxi.sim.grayscott"
+  include_package "toxi.math"
+  include_package "toxi.color"
+end
+
+attr_reader :gs, :tone_map, :img
+
+def setup
+  size 256, 256
+  @gs = Toxi::GrayScott.new width, height, true
+  @img = load_image "ti_yong.png"
+  # create a duo-tone gradient map with 256 steps
+  # NB: use '::' in place of '.' here for these java constants
+  @tone_map = Toxi::ToneMap.new(0,  0.33, Toxi::NamedColor::CRIMSON, Toxi::NamedColor::WHITE, 256)
+end
+
+def draw
+  @gs.seed_image(img.pixels, img.width, img.height)
+  @gs.set_rect(mouse_x, mouse_y, 20, 20) if mouse_pressed? 
+  load_pixels
+  10.times { @gs.update(1) }
+  # read out the V result array
+  # and use tone map to render colours
+  gs.v.length.times do |i|
+    pixels[i]=tone_map.getARGBToneFor(gs.v[i])  # NB: don't camel case convert here
+  end
+  update_pixels
+end
+
+def key_pressed
+  case key
+  when '1', '9', '3', '2', '4', '6', '5', '7', '8'
+    @gs.setF(0.02 + (key.ord - 48) * 0.001)
+  when 's'
+    save_frame "toxi.png"
+  else
+    @gs.reset()
+  end
+end
+
+

data/samples/external_library/java_processing/toxiclibs/gray_scott_tone_map.rb

@@ -0,0 +1,78 @@
+#
+# <p>GrayScottToneMap shows how to use the ColorGradient & ToneMap classes of the
+# colorutils package to create a tone map for rendering the results of
+# the Gray-Scott reaction-diffusion.</p>
+#
+# <p><strong>Usage:</strong><ul>
+# <li>click + drag mouse to draw dots used as simulation seed</li>
+# <li>press any key to reset</li>
+# </ul></p>
+#
+
+# 
+# Copyright (c) 2010 Karsten Schmidt
+# 
+# This demo & library is free software you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation either
+# version 2.1 of the License, or (at your option) any later version.
+# 
+# http://creativecommons.org/licenses/LGPL/2.1/
+# 
+# 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+load_libraries 'simutils','toxiclibscore','colorutils'
+include_package "toxi.sim.grayscott"
+include_package "toxi.math"
+include_package "toxi.color"
+
+NUM_ITERATIONS = 10
+
+attr_reader :gs, :tone_map
+
+def setup 
+    size(256,256)
+    @gs= GrayScott.new width,height, false
+    @gs.set_coefficients 0.021, 0.076, 0.12, 0.06
+    # create a color gradient for 256 values
+    grad = ColorGradient.new
+    # NamedColors are preset colors, but any TColor can be added
+    # see javadocs for list of names:
+    # http://toxiclibs.org/docs/colorutils/toxi/color/NamedColor::html
+    # NB: use '::' in place of '.' here for these java constants
+    grad.add_color_at(0, NamedColor::BLACK)
+    grad.add_color_at(128, NamedColor::RED)
+    grad.add_color_at(192, NamedColor::YELLOW)
+    grad.add_color_at(255, NamedColor::WHITE)
+    # this gradient is used to map simulation values to colors
+    # the first 2 parameters define the min/max values of the
+    # input range (Gray-Scott produces values in the interval of 0.0 - 0.5)
+    # setting the max = 0.33 increases the contrast
+    @tone_map = ToneMap.new 0, 0.33, grad
+end
+
+def draw     
+    @gs.set_rect(mouse_x, mouse_y, 20, 20) if mouse_pressed?
+    load_pixels
+    # update the simulation a few time steps
+    NUM_ITERATIONS.times { @gs.update(1) }
+    # read out the V result array
+    # and use tone map to render colours
+    gs.v.length.times do |i|
+        pixels[i]=tone_map.getARGBToneFor(gs.v[i])  # NB: don't camel case convert here
+    end
+    update_pixels
+end
+
+def key_pressed
+    @gs.reset()
+end
+

data/samples/external_library/java_processing/toxiclibs/implicit.rb

@@ -0,0 +1,143 @@
+
+#
+# This example implements a custom VolumetricSpace using an implicit function
+# to calculate each voxel. This is slower than the default array or HashMap
+# based implementations, but also has much less memory requirements and so might
+# be an interesting and more viable approach for very highres voxel spaces
+# (e.g. >32 million voxels). This implementation here also demonstrates how to
+# achieve an upper boundary on the iso value (in addition to the one given and
+# acting as lower threshold when computing the iso surface)
+#
+# Usage:
+# move mouse to rotate camera
+# -/=: zoom in/out
+# l: apply laplacian mesh smooth
+# 
+#
+
+# 
+# Copyright (c) 2010 Karsten Schmidt & ruby-processing version Martin Prout 2013
+# This sketch relies on a custom ruby-processing mesh_to_vbo library
+# 
+# This library is free software you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation either
+# version 2.1 of the License, or (at your option) any later version.
+# 
+# http://creativecommons.org/licenses/LGPL/2.1/
+# 
+# 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+load_libraries 'toxiclibscore', 'vbo', 'volumeutils'
+
+module Toxi
+  include_package 'toxi.geom'
+  include_package 'toxi.geom.mesh'
+  include_package 'toxi.volume'
+  include_package 'toxi.processing'
+end
+
+RES = 64
+ISO = 0.2
+MAX_ISO = 0.66
+
+attr_reader :mesh, :vbo, :curr_zoom, :implicit
+
+def setup
+  size(720,720, P3D)
+  @vbo = MeshToVBO.new(self)
+  @curr_zoom = 1
+  vol = EvaluatingVolume.new(Toxi::Vec3D.new(400,400,400), RES, RES, RES, MAX_ISO)
+  surface = Toxi::HashIsoSurface.new(vol)
+  @mesh = Toxi::WETriangleMesh.new
+  surface.compute_surface_mesh(mesh, ISO)
+  @is_wire_frame = false
+  no_stroke
+  @implicit = vbo.meshToVBO(mesh, true)
+  implicit.setFill(color(222, 222, 222))
+  implicit.setAmbient(color(50, 50, 50))
+  implicit.setShininess(color(10, 10, 10))
+  implicit.setSpecular(color(50, 50, 50))
+end
+
+def draw
+  background(0)
+  lights
+  define_lights
+  translate(width / 2.0, height / 2.0, 0)
+  rotate_x(mouse_y * -0.01)
+  rotate_y(mouse_x * -0.01)
+  scale(curr_zoom)
+  shape(implicit)
+end
+
+def key_pressed
+  case key
+  when '-'
+    @curr_zoom -= 0.1
+  when '='
+    @curr_zoom += 0.1
+  when 'l', 'L'
+    Toxi::LaplacianSmooth.new.filter(mesh, 1)
+    @implicit = vbo.meshToVBO(mesh, true)
+    # new mesh so need to set finish
+    implicit.setFill(color(222, 222, 222))
+    implicit.setAmbient(color(50, 50, 50))
+    implicit.setShininess(color(10, 10, 10))
+    implicit.setSpecular(color(50, 50, 50))
+  when 's', 'S'
+    save_frame("implicit.png")
+  end
+end
+
+def define_lights  
+  ambient_light(50, 50, 50)
+  point_light(30, 30, 30, 200, -150, 0)
+  directional_light(0, 30, 50, 1, 0, 0)
+  spot_light(30, 30, 30, 0, 40, 200, 0, -0.5, -0.5, PI / 2, 2)
+end
+
+class EvaluatingVolume < Toxi::VolumetricSpace
+  include Processing::Proxy
+  java_import 'toxi.math.SinCosLUT'
+  
+  attr_reader :upper_bound, :lut
+  FREQ = PI * 3.8
+  
+  def initialize(scal_vec, resX, resY, resZ, upper_limit)
+    super(scal_vec, resX, resY, resZ)
+    @upper_bound = upper_limit
+    @lut=SinCosLUT.new
+  end
+  
+  def clear
+    # nothing to do here
+  end
+  
+  def getVoxelAt(i)
+    getVoxel(i % resX, (i % sliceRes) / resX, i / sliceRes)
+  end
+  
+  def getVoxel(x, y, z)  # can't overload so we renamed
+    val = 0
+    if (x > 0 && x < resX1 && y > 0 && y < resY1 && z > 0 && z < resZ1)
+      xx = x * 1.0 / resX - 0.5  # NB: careful about integer division !!!
+      yy = y * 1.0 / resY - 0.5
+      zz = z * 1.0 / resZ - 0.5
+      #val = lut.sin(xx * FREQ) + lut.cos(yy * FREQ) + lut.sin(zz * FREQ)
+      val = lut.cos(xx * FREQ) * lut.sin(yy* FREQ) + lut.cos(yy* FREQ) * lut.sin(zz* FREQ) + lut.cos(zz* FREQ)* lut.sin(xx* FREQ)
+      if (val > upper_bound)
+        val = 0
+      end
+    end
+    return val
+  end
+end

data/samples/external_library/java_processing/toxiclibs/library/vbo/mesh_to_vbo.rb

@@ -0,0 +1,52 @@
+############################################
+# mesh_to_vbo.rb
+# a ruby library to convert toxi.mesh object
+# to vbo (PShape) written by Martin Prout
+# make use of Processing::Proxy mixin
+############################################
+class MeshToVBO
+  include Processing::Proxy
+  
+  attr_reader :parent
+  
+  def initialize(parent)
+    @parent = parent   
+  end
+  
+  def meshToVBO(mesh, smth)
+    retained = parent.createShape()
+    retained.begin_shape(PShape::TRIANGLES)
+    if (smth)
+      mesh.computeVertexNormals()
+      mesh.getFaces.each do |f|
+        retained.normal(f.a.normal.x, f.a.normal.y, f.a.normal.z)
+        retained.vertex(f.a.x, f.a.y, f.a.z)
+        retained.normal(f.b.normal.x, f.b.normal.y, f.b.normal.z)
+        retained.vertex(f.b.x, f.b.y, f.b.z)
+        retained.normal(f.c.normal.x, f.c.normal.y, f.c.normal.z)
+        retained.vertex(f.c.x, f.c.y, f.c.z)
+      end
+    else
+      mesh.getFaces.each do |f|
+        retained.normal(f.normal.x, f.normal.y, f.normal.z)
+        retained.vertex(f.a.x, f.a.y, f.a.z)
+        retained.vertex(f.b.x, f.b.y, f.b.z)
+        retained.vertex(f.c.x, f.c.y, f.c.z)
+      end
+    end
+    retained.end_shape()
+    return retained
+  end
+  
+  # variant
+  # input array of meshes, output an array of shapes
+  def meshToRetained(mesh, smth)
+    rshapes = []
+    (0 ... mesh.length).each do |i|
+      rshapes.push(meshToVBO(mesh[i], smth))
+    end
+    return rshapes
+  end
+end
+
+

data/samples/external_library/java_processing/toxiclibs/model_align.rb

@@ -0,0 +1,55 @@
+# This example demonstrates how to rotate a number of meshes
+# so that each points towards a common & user controlled focal point.
+#
+# Requires toxiclibs-0020 or newer
+#
+# (c) 2012 Karsten Schmidt / LGPL2 licensed
+#
+load_libraries 'toxiclibscore', 'toxiclibs_p5', 'colorutils'
+
+module Toxi
+  include_package 'toxi.geom'
+  include_package 'toxi.geom.mesh'
+  include_package 'toxi.processing'
+end
+
+# container for mesh positions
+
+attr_reader :gfx, :positions
+
+def setup
+  size(640,480,P3D)
+  @gfx = Toxi::ToxiclibsSupport.new(self)
+  @positions = []
+  # compute mesh positions on circle in XZ plane
+  (Toxi::Circle.new(200).toPolygon2D(8)).each do |p|
+    positions << p.to3DXZ
+  end
+end
+
+def draw
+  background(51)
+  lights
+  no_stroke
+  translate(width/2,height/2,0)
+  rotate_x(-PI/6)
+  # create manual focal point in XY plane
+  focus = Toxi::Vec3D.new((mouse_x - width/2), (mouse_y - height/2), 0)
+  # create mesh prototype to draw at all generated positions
+  # the mesh is a simple box placed at the world origin
+  m = Toxi::AABB.new(25).to_mesh
+  # draw focus
+  gfx.box(Toxi::AABB.new(focus, 5))
+  positions.each do |p|
+    # align the positive z-axis of mesh to point at focus
+    # mesh needs to be located at world origin for it to work correctly
+    # only once rotated, move it to actual position
+    gfx.mesh(m.copy.pointTowards(focus.sub(p), Toxi::Vec3D::Z_AXIS).translate(p))
+  end
+  # draw connections from mesh centers to focal point
+  stroke(0,255,255)
+  positions.each do |p|
+    gfx.line(p, focus)
+  end
+end
+

data/samples/external_library/ruby_gem/README

@@ -0,0 +1,12 @@
+The absolute belt and brace way to use external ruby libraries ie gems:
+
+1. Install ruby-processing using jruby
+   jruby -S gem install ruby-processing (or from a local gem currently)
+2. Install any required rubygems the same way
+3. "require" the library in your sketch
+4. Run ruby-processing starting from jruby
+   jruby -S rp5 run sketch.rb
+
+See worked perlin_force and mdarray_test in this folder 
+NB: library will need to work with jruby this excludes most native libraries
+but pure ruby libraries (+java) should be fine

data/samples/external_library/ruby_gem/data/README.txt

@@ -0,0 +1 @@
+The java_args.txt is used to send command line args to jvm/jruby....

data/samples/external_library/ruby_gem/data/java_args.txt

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

data/samples/external_library/ruby_gem/game_of_life.rb

@@ -0,0 +1,127 @@
+# game_of_life.rb featuring MDArray in ruby-processing
+# A Processing implementation of Game of Life
+# By Joan Soler-Adillon
+#
+# Press SPACE BAR to pause and change the cell's values with the mouse
+# On pause, click to activate/deactivate cells
+# Press R to randomly reset the cells' grid
+# Press C to clear the cells' grid
+#
+# The original Game of Life was created by John Conway in 1970.
+#
+
+require 'mdarray'
+
+CELL_SIZE = 5
+ALIVE = true
+DEAD = false
+ALIVE_START = 150
+WIDTH = 960
+HEIGHT = 640
+SKIP = 10
+INTERVAL = 100
+
+attr_reader :pause, :cells, :row, :column, :last_time, :alive, :cells_buffer
+
+def setup
+  size WIDTH, HEIGHT
+  @row = WIDTH / CELL_SIZE
+  @column = HEIGHT / CELL_SIZE
+  background 0
+  stroke_weight 2
+  @last_time = 0
+  @pause = false
+  @cells = MDArray.boolean([row, column], random_data)
+  @alive = color(100, 255, 100)
+  stroke(48, 100)
+  no_smooth
+end
+
+def draw
+  background(0)
+  #Draw live cells
+  (0 ... row).each do |x|
+    (0 ... column).each do |y|
+      if (cells.get([x, y]))
+        fill(alive)
+        rect(x * CELL_SIZE, y * CELL_SIZE, CELL_SIZE, CELL_SIZE)
+      end
+    end
+  end
+  # Iterate if timer ticks
+  if (millis - last_time > INTERVAL)
+    if (!pause)
+      tick!
+      @last_time = millis
+    end
+  end
+  
+  # Create  new cells manually on pause
+  if (pause && mouse_pressed?)
+    # # Map and avoid out of bound errors
+    x_cell_over = (map(mouse_x, 0, width, 0, row)).to_i
+    x_cell_over = constrain(x_cell_over, 0, row - 1)
+    y_cell_over = (map(mouse_y, 0, height, 0, column)).to_i
+    y_cell_over = constrain(y_cell_over, 0, column - 1)
+    
+    # Check against cells in buffer
+    if (cells_buffer.get([x_cell_over, y_cell_over]))  # Cell is alive
+      cells.set([x_cell_over, y_cell_over], DEAD) # Kill
+      fill(0) #reflect changed status
+    else  # Cell is dead
+      cells.set([x_cell_over, y_cell_over], ALIVE) # Make alive
+      fill(alive) # Fill alive color
+    end
+    
+  elsif (pause && !mouse_pressed?)  # And then save to buffer once mouse goes up
+    # Save cells to buffer (so we operate with one array keeping the other intact)
+    @cells_buffer = cells.copy
+  end
+end
+
+def tick!  # When the clock ticks
+  # Save cells to buffer (so we operate with one array keeping the other intact)
+  @cells_buffer = cells.copy
+  # Visit each cell:
+  (0 ... row).each do |x|
+    (0 ... column).each do |y|
+      # And visit all the neighbours of each cell
+      neighbours = 0 # We'll count the neighbours
+      (x - 1 .. x + 1).each do |xx|
+        (y - 1 .. y + 1).each do |yy|
+          # Make sure you are not out of bounds
+          if [(xx>=0), (xx<row), (yy>=0), (yy<column)].all? {|in_bounds| in_bounds == true}
+            # Make sure to check against self
+            if ![(xx == x), (yy == y)].all? {|is_self| is_self == true}
+              if (cells_buffer.get([xx, yy])) # true == ALIVE
+                neighbours += 1 # Check alive neighbours and count them
+              end # alive
+            end # End of if self
+          end # End of if grid bounds
+        end # End of yy loop
+      end #End of xx loop
+      # We've checked the neighbours: apply rules in one line (only in ruby)!
+      cells.set([x, y], (cells_buffer.get([x, y]))?  ((2 .. 3) === neighbours) : (neighbours == 3))
+    end # End of y loop
+  end # End of x loop
+end # End of function
+
+def key_pressed
+  case key
+  when 'r', 'R'
+    # Restart: reinitialization of cells 
+    @cells = MDArray.boolean([row, column], random_data)
+  when ' ' # On/off of pause
+    @pause = !pause
+  when 'c', 'C' # Clear all
+    @cells = MDArray.boolean([row, column], DEAD)
+  end
+end
+
+def random_data
+  data = []
+  (0 ... row * column).each do
+    data << (rand(1000) < ALIVE_START)
+  end
+  return data
+end