ruby-processing 2.6.3 → 2.6.4

data/samples/processing_app/library/vecmath/vec3d/library/geometry/lib/plane.rb

@@ -1,60 +0,0 @@
-NORM_LEN = 225.0
-
-class Plane
-  include Processing::Proxy
-  
-  attr_reader :vecs, :c, :n
-
-
-  def initialize(vecs)
-    @vecs = vecs
-    init
-  end
-  
-  def init    
-    v1 = vecs[1] - vecs[0] 
-    v2 = vecs[2] - vecs[0]  
-    
-    @c = Vec3D.new(
-      (vecs[0].x + vecs[1].x + vecs[2].x) / 3, 
-      (vecs[0].y + vecs[1].y + vecs[2].y) / 3, 
-      (vecs[0].z + vecs[1].z + vecs[2].z) / 3
-      )
-    
-    @n = v1.cross(v2)
-    n.normalize!
-  end
-  
-  def display(renderer)
-    begin_shape(TRIANGLES)
-    vecs.map { |vec| vec.to_vertex(renderer) }
-    end_shape
-    
-    #normal
-    stroke(200, 160, 30)
-    begin_shape(LINES)
-    c.to_vertex(renderer)
-    (c + n * NORM_LEN).to_vertex(renderer)
-    end_shape
-    
-    #binormal
-    stroke(160, 200, 30)
-    begin_shape(LINES)
-    c.to_vertex(renderer)
-    # tangent
-    v = vecs[1].copy
-    #v.set(vecs[1])
-    v -= vecs[0]
-    v.normalize!
-    (c + v * NORM_LEN).to_vertex(renderer)
-    end_shape
-    
-    stroke(30, 200, 160)
-    begin_shape(LINES)
-    c.to_vertex(renderer)
-    b = v.cross(n)
-    (c + b * NORM_LEN).to_vertex(renderer)
-    end_shape
-    stroke(0, 75)
-  end
-end

data/samples/processing_app/library/vecmath/vec3d/library/hilbert/hilbert.rb

@@ -1,84 +0,0 @@
-############################
-# Simple lsystem grammar
-############################
-class Grammar
-  def initialize(axiom, rules)
-    @axiom = axiom
-    @rules = rules
-  end
-
-  def expand(production, iterations, &block)
-    production.each_char do |token|
-      if @rules.has_key?(token) && iterations > 0 
-        expand(@rules[token], iterations - 1, &block)
-      else
-        yield token
-      end
-    end
-  end
-
-  def each gen
-    expand(@axiom, gen) {|token| yield token }
-  end
-
-  def generate gen
-    output = []
-    each(gen) { |token| output << token }
-    output
-  end
-
-end
-
-
-############################
-# Hilbert Curves
-###########################
-class Hilbert
-  include Processing::Proxy
-  attr_reader :grammar, :axiom, :production, :premis, :rule,
-  :theta, :distance, :phi, :gen, :adj_array
-
-  def initialize(size: 1.0, gen: 1)
-    @axiom = 'X'                                           # AXIOM
-    @rule = {'X' => '^<XF^<XFX-F^>>XFX&F+>>XFX-F>X->'}     # RULE
-    @gen = gen
-    @grammar = Grammar.new(axiom, rule) 
-    @production = grammar.generate gen
-    @distance = size / (gen**2 - 1)
-    @theta = 90.radians
-    @phi = 90.radians  
-    @adj_array = [0, 0.5, 1.5, 3.5, 7.5, 15].map { |x| Vec3D.new(x * -1, x, x * -1) }
-  end
-
-  def draw    
-    adj = adj_array[gen] * distance
-    translate(adj.x, adj.y, adj.z)
-    fill(0, 75, 152)
-    light_specular(204, 204, 204)
-    specular(255, 255, 255)
-    shininess(1.0)
-    production.each do |ch|
-      case(ch)
-      when 'F'
-        translate(0, distance / -2, 0)
-        box(distance/9 , distance, distance/9)
-        translate(0, distance / -2, 0)
-      when '+'
-        rotateX(-theta)
-      when '-'
-        rotateX(theta)
-      when '>'
-        rotateY(theta)
-      when '<'
-        rotateY(-theta)
-      when '&'
-        rotateZ(-phi)
-      when '^'
-        rotateZ(phi)
-      when 'X'
-      else
-        puts("character '#{ch}' not in grammar")
-      end
-    end
-  end
-end   

data/samples/processing_app/library/vecmath/vec3d/note.txt

@@ -1 +0,0 @@
-retained menger requires compat.version=2.0 (jruby-1.7.xx)

data/samples/processing_app/library/vecmath/vec3d/retained_menger.rb

@@ -1,115 +0,0 @@
-##########################
-# RetainedMenger.rb
-# (processing-2.0)
-# author Martin Prout
-##########################
-
-load_library :vecmath
-
-PTS = [-1, 0, 1]
-MIN_SIZE = 20
-
-attr_reader :menger
-
-def setup
-  size(640, 480, P3D)
-  smooth(8)
-  ArcBall.init(self)
-  @menger = create_shape(GROUP)
-  create_menger(0, 0, 0, height * 0.8)
-end
-
-def draw
-  background(20, 20, 200)
-  no_stroke
-  lights
-  define_lights
-  render
-end
-
-def render
-  menger.set_fill(color(224, 223, 219))
-  menger.set_ambient(50)
-  menger.set_specular(150)
-  shape(menger)
-end
-
-def create_menger(xx, yy, zz, sz)
-  u = sz / 3.0
-  if sz < MIN_SIZE # recursion limited by minimum cube size
-    no_stroke
-    menger.add_child(create_cube(xx, yy, zz, sz)) # create and add a cube
-  else
-    PTS.each do |i|
-      PTS.each do |j|
-        PTS.each do |k|
-          if (i.abs + j.abs + k.abs) > 1
-            create_menger(xx + (i * u), yy + (j * u), zz + (k * u), u)
-          end
-        end
-      end
-    end
-  end
-end
-
-def create_cube(xx, yy, zz, sz)
-  dim = sz / 2.0
-  cube = create_shape
-  cube.begin_shape(QUADS)
-  # Front face
-  cube.fill(255)
-  cube.normal(0, 0, 1)
-  cube.vertex(-dim + xx, -dim + yy, -dim + zz)
-  cube.vertex(+dim + xx, -dim + yy, -dim + zz)
-  cube.vertex(+dim + xx, +dim + yy, -dim + zz)
-  cube.vertex(-dim + xx, +dim + yy, -dim + zz)
-
-  # Back face
-
-  cube.normal(0, 0, -1)
-  cube.vertex(-dim + xx, -dim + yy, +dim + zz)
-  cube.vertex(+dim + xx, -dim + yy, +dim + zz)
-  cube.vertex(+dim + xx, +dim + yy, +dim + zz)
-  cube.vertex(-dim + xx, +dim + yy, +dim + zz)
-
-  # Left face
-
-  cube.normal(1, 0, 0)
-  cube.vertex(-dim + xx, -dim + yy, -dim + zz)
-  cube.vertex(-dim + xx, -dim + yy, +dim + zz)
-  cube.vertex(-dim + xx, +dim + yy, +dim + zz)
-  cube.vertex(-dim + xx, +dim + yy, -dim + zz)
-
-  # Right face
-
-  cube.normal(-1, 0, 0)
-  cube.vertex(+dim + xx, -dim + yy, -dim + zz)
-  cube.vertex(+dim + xx, -dim + yy, +dim + zz)
-  cube.vertex(+dim + xx, +dim + yy, +dim + zz)
-  cube.vertex(+dim + xx, +dim + yy, -dim + zz)
-
-  # Top face
-
-  cube.normal(0, 1, 0)
-  cube.vertex(-dim + xx, -dim + yy, -dim + zz)
-  cube.vertex(+dim + xx, -dim + yy, -dim + zz)
-  cube.vertex(+dim + xx, -dim + yy, +dim + zz)
-  cube.vertex(-dim + xx, -dim + yy, +dim + zz)
-
-  # Bottom face
-
-  cube.normal(0, -1, 0)
-  cube.vertex(-dim + xx, +dim + yy, -dim + zz)
-  cube.vertex(+dim + xx, +dim + yy, -dim + zz)
-  cube.vertex(+dim + xx, +dim + yy, +dim + zz)
-  cube.vertex(-dim + xx, +dim + yy, +dim + zz)
-  cube.end_shape
-  return cube
-end
-
-def define_lights
-  ambient_light(50, 50, 50)
-  point_light(30, 30, 30, 200, 240, 0)
-  directional_light(50, 50, 50, 1, 0, 0)
-  spot_light(30, 30, 30, 0, 40, 200, 0, -0.5, -0.5, PI / 2, 2)
-end

data/samples/processing_app/topics/advanced_data/README

@@ -1 +0,0 @@
-Some sketches in this folder may need to be run with the "--nojruby" flag. eg threads_two.rb, and word_frequency.rb the load_json.rb relies json or json-ruby gem.

data/samples/processing_app/topics/advanced_data/Rakefile

@@ -1,30 +0,0 @@
-# Simple demo Rakefile to autorun samples in current directory
-# adjust path to rp5 executable, and or opts as required
-
-SAMPLES_DIR = './'
-
-desc 'run demo'
-task default: [:demo]
-
-desc 'demo'
-task :demo do
-  samples_list.shuffle.each{ |sample| run_sample sample }
-end
-
-def samples_list
-  files = []
-  Dir.chdir(SAMPLES_DIR)
-  Dir.glob('*.rb').each do |file|
-    files << File.join(SAMPLES_DIR, file)
-  end
-  return files
-end
-
-def run_sample(sample_name)
-  puts "Running #{sample_name}...quit to run next sample"
-  open("|rp5 --nojruby run #{sample_name}", 'r') do |io|
-    while l = io.gets
-      puts(l.chop)
-    end      
-  end
-end

data/samples/processing_app/topics/advanced_data/counting_words.rb

@@ -1,79 +0,0 @@
-class Word
-  # A helper to keep track of word frequency.
-  attr_accessor :word
-  attr_reader :count
-  def initialize word
-    @word = word
-    @count = 1
-  end
-
-  def increment
-    @count += 1
-  end
-end
-
-################################
-# This sketch is translated from a vanilla processing sketch by Daniel Schiffman
-# that was designed to demonstrate the use IntHash class in vanilla processing.
-# Similar results can easily be obtained using more idiomatic ruby. Here IntHash
-# has been replaced by a String => Word hash (as used in a Schiffman prototype).
-# Read about concordance here:-
-# http://en.wikipedia.org/wiki/Concordance_(publishing)
-################################
-
-attr_reader :concordance, :lines, :tokens, :counter
-
-def setup
-  size 640, 360
-  @counter = 0
-  @concordance = {}
-  # Open a file, read its contents, and 'scan' for words using a regex.
-  # Include words with apostrophe eg Harker's
-  @tokens = File.read(data_path('dracula.txt')).scan(/[\w'-]+/)
-  text_font(create_font('Georgia', 24))
-end
-
-def draw
-  background 51
-  fill 255
-  s = (tokens[counter] == 'I')? tokens[counter] : tokens[counter].downcase
-  @counter = (counter + 1) % tokens.length
-  if (concordance.has_key?(s))
-    # Get the word object and increase the count
-    # We access objects from a Hash via its key, the String
-    w = concordance[s]
-    w.increment    # increment word count
-  else
-    # Otherwise make a new Word instance and add it to
-    # the Hash using the word String as the key
-    concordance[s] = Word.new(s)
-  end
-
-  # x and y will be used to locate each word
-  x = 0
-  y = height - 10
-
-  # Look at each word
-  concordance.values.each do |w|
-    # Only display words that appear 3 times
-    if (w.count > 3)  # access word count
-      # The size is the count
-      fsize = constrain(w.count, 0, 100)
-      text_size(fsize)
-      text(w.word, x, y)
-      # Move along the x-axis
-      x += text_width(w.word) + 1
-    end
-
-    # If x gets to the end, move y
-    # If y == 0 we are done
-    if (y == 0)
-      no_loop
-    else
-      if (x > width)
-        x = 0
-        y = (y < 0)? 0 : y - 100
-      end
-    end
-  end
-end