picrate 0.0.2-java → 0.0.3-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 292bad32642f52265d09b224e75f536f2548947a5e1631f6f41e53376cdc6769
-  data.tar.gz: 299f55ed80ae243525eafcc9286687486732a2faf153e15ad457b19f584937c7
+  metadata.gz: 3356804d4e8a73be8e31daceea79e551d0874f3aeb4e4e62b12ab9c4b2dd49de
+  data.tar.gz: 0a92a0e1a62969be5678c160701408c390fb67dd2bfeb0d3a57c6c95e68befa9
 SHA512:
-  metadata.gz: 8d835c17104b60279636de242146cb89684aefe07766edcc6bde7f3523305d00405928d60d33d528fbbe2c85750c44945d0a87ab3f424f8eb02433001f792590
-  data.tar.gz: 3b56360f1c6321eec552b543453944d9eda164f46ffd2c9398edcb8a77d2674ac02295b0693d345d0505d1abe3d038239a4d04b9c9402a65d746e61b0baa8242
+  metadata.gz: 791e4d54e4d1576ade00904c2d032ca0526a9245174f3d7a2ebb7ca1b84f5b99eb22b7c981564ed3f68790e9fe6cf21fbc00ab4bc1b2ef02daea49bc168188f5
+  data.tar.gz: 922bf6e7884fd966fe2b631fe1f61fb4b61ea4b9327643c365ab1d7d259fe3b95afd4fe7b182720d113a85e53a1a5f74560f9cfc36a64b0af01ac84279b389d4

data/README.md

@@ -1,7 +1,8 @@
-__C6H3N3O7__ [![Build Status](https://travis-ci.org/ruby-processing/PiCrate.svg?branch=master)](https://travis-ci.org/ruby-processing/PiCrate)
+__C6H3N3O7__ [![Build Status](https://travis-ci.org/ruby-processing/PiCrate.svg?branch=master)](https://travis-ci.org/ruby-processing/PiCrate) 
+[![Gem Version](https://badge.fury.io/rb/picrate.svg)](https://badge.fury.io/rb/picrate)
 
 # PiCrate
-Create processing sketches in ruby on raspberry-pi and linux (this project is a parallel development of [propane][propane] targetting the raspberry-pi, but will initially be developed on a regular linux box). The aim is to produce a gem installable app that can be run with jruby, with minimal dependencies.
+Create processing sketches in ruby on raspberry-pi and linux (this project is a parallel development of [picrate][picrate] targetting the raspberry-pi, but will initially be developed on a regular linux box). The aim is to produce a gem installable app that can be run with jruby, with minimal dependencies.
 
 ### To Build and Test ###
 
@@ -12,7 +13,7 @@ Requires maven, jdk8 (can be openjdk), and a jruby install.
 ```bash
 cd PiCrate
 rake
-jgem install picrate-0.0.1-java.gem
+jgem install picrate-0.0.2-java.gem
 ```
 To create a template sketch:-
 ```bash
@@ -48,4 +49,4 @@ jruby my_sketch.rb
 ```
 
 
-[propane]:https://ruby-processing.github.io/propane/
+[picrate]:https://ruby-processing.github.io/picrate/

data/Rakefile

@@ -21,7 +21,7 @@ end
 desc 'Install'
 task :install do
   sh 'mvn dependency:copy'
-  sh 'mv target/picrate-0.0.2.jar lib'
+  sh 'mv target/picrate-0.0.3.jar lib'
 end
 
 desc 'Gem'

data/docs/_classes/aabb/aabb.md

@@ -0,0 +1,28 @@
+---
+layout: page
+title:  "AaBb"
+permalink:   /classes/aabb/
+---
+
+AaBb is a 2D axis aligned bounding box for propane
+
+Constructors:-
+```ruby
+# Regular constructor where vec_one and vec_two are instances of Vec2D
+AaBb.new(center: vec_one, extent: vec_two)
+# Alternative constructor where vec_one and vec_two are instances of Vec2D
+AaBb.new(min: vec_one, max: vec_two)
+```
+
+Methods:-
+```ruby
+center # returns the AaBb center Vec2D
+extent # returns the AaBb extent as Vec2D
+position(vec)           # set the center as vec
+position(vec) { block } # set the center as vec, if block evaluates to true
+contains?(vec)          # returns true/false if box contains point at vec
+```
+
+Example: [Constrained Box][example]
+
+[example]: https://github.com/ruby-processing/picrate-examples/blob/master/library/vecmath/vec2d/aabb_test.rb

data/docs/_classes/app/app.md

@@ -0,0 +1,38 @@
+---
+layout: post
+title:  "App"
+keywords: App, PApplet
+---
+The `App` class (`Processing::App`) is a subclass of `PApplet`, and one way or another your propane sketch inherits from `Processing::App`, it is just not obvious in a `nude` or `bare` propane sketch.  Unless you explicitly create your own Sketch class, the default is to create an instance of `Sketch < Processing::App` as below. What a bare sketch would look like when wrapped prior to eval.
+
+```ruby
+class Sketch < Processing::App
+  # your bare sketch code may include 'draw' should include 'settings'
+end
+
+Sketch.new
+```
+
+What a nude static sketch would look like when wrapped prior to eval.
+
+```ruby
+class Sketch < Processing::App
+  def setup
+    sketch_title 'Nude Sketch'
+    # your nude sketch code here eg `background 0`
+    no_loop
+  end
+  def settings
+    size(150, 150)
+  end
+end
+
+Sketch.new
+```
+You should be aware that all vanilla processing sketches are similary wrapped prior to java compilation.  The idea of processing and also propane is to make it easy to create sketches, so this is all you need to know, and you should probably look at [propane][propane] if you really prefer class wrapped sketches.
+
+For propane see also [Processing][processing] module for more details, you could also see [magic][magic] (_but it 'really' is not necessary_)
+
+[propane]:https://ruby-processing.github.io/propane/
+[processing]:{{ site.github.url }}/modules/processing
+[magic]:{{ site.github.url }}/magic.html

data/docs/_classes/app_render/app_render.md

@@ -0,0 +1,93 @@
+---
+layout: post
+title:  "AppRender and ShapeRender"
+keywords: to_vertex, Vec3D, Vec2D, AppRender, ShapeRender
+---
+Vec2D and Vec3D classes can be efficiently rendered as both PApplet vertices, and PShape vertices using AppRender and ShapeRender utility classes. To use the AppRender renderer you should create a single instance in the processing setup see below example:-
+
+### AppRender
+
+```ruby
+attr_reader :renderer
+...
+def setup
+  @renderer = AppRender.new(self)
+end
+...
+```
+
+Note the use of `attr_reader` so we can access the `renderer` outside of `setup`. Here is a snippet of code for a 2D sketch, where we draw a polygon outline directly using the processing vertex (nested within `begin_shape` and `end_shape(CLOSE)`). All we need to do is supply our renderer as an argument to the Vec2D `:to_vertex` instance method.
+
+```ruby
+...
+begin_shape # Vec2D example
+  no_fill
+  stroke(255)
+  morph.each do |v|
+    v.to_vertex(renderer)
+  end
+end_shape(CLOSE)
+...
+```
+
+If you chose not use the renderer, this is how the code would look, requires more ruby to java conversions:-
+
+```ruby
+...
+begin_shape # Vec2D example
+  no_fill
+  stroke(255)
+  morph.each do |v|
+    vertex(v.x, v.y)
+  end
+end_shape(CLOSE)
+...
+```
+
+### ShapeRender
+
+Usage of the ShapeRender is similar, except that you need to `create_shape` first, and it is the created `shape` that needs to be available in the draw loop. Here is a code snippet for use of a `ShapeRender` with `Vec2D`, where `original` is an array of `Vec2D` describing a closed polygon. We use an attr_reader for `s` so that we can define it one block of code and use `shape(s)` to call it in the draw loop in the normal way for a 'retained shape/vbo'.
+
+```ruby
+attr_reader :s
+...
+@s = create_shape
+renderer = ShapeRender.new(s)
+s.begin_shape
+s.fill(127)
+s.stroke(0)
+s.stroke_weight(2)
+original.map{ |v| v.to_vertex(renderer) }
+s.end_shape(CLOSE)
+...
+shape(s)
+```
+
+There is also the possibility of adding texture see this `ShapeRender` usage snippet:-
+
+```ruby
+...
+# 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
+renderer = ShapeRender.new(mesh) # initialize the shape renderer
+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 do |p, i|
+  t = tex_coords[i]
+  p.to_vertex_uv(renderer, t.x, t.y)
+end
+mesh.end_shape
+...
+```
+
+The above snippet is taken from the [glsl_heighmap_noise.rb sketch][glsl], for another example of the advanced use of the ShapeRender class see the [trefoil sketch][trefoil]. Warning if you are using ShapeRender inside a custom class you need to prefix it with the sketch class name `Sketch::` for bare sketches, see [wiggle_pshape][wiggling] sketch.
+
+[glsl]:https://github.com/ruby-processing/picrate-examples/blob/master/topics/shaders/glsl_heightmap_noise.rb
+[trefoil]:https://github.com/ruby-processing/picrate-examples/blob/master/demos/graphics/trefoil.rb
+[wiggling]:https://github.com/ruby-processing/picrate-examples/blob/master/library/vecmath/vec2d/wiggle_pshape.rb

data/docs/_classes/arc_ball/arc_ball.md

@@ -0,0 +1,33 @@
+---
+layout: page
+title:  "ArcBall"
+permalink: /classes/arcball/
+---
+
+ArcBall is a user input interface to make a 3D object rotate in an intuitive way. It uses quaternions to represent orientations, although this implementation detail is hidden in propane. Use the ArcBall to enable mouse drag rotation and mouse wheel zoom in 3D sketches. Hold down x, y or z keys to constrain the rotation axis.
+
+See a simple example below, where the box (a cube in this case) gets centered in the middle of the display. 
+
+```ruby
+def setup
+  sketch_title 'Arcball Box'
+  ArcBall.init self
+  fill 180
+end
+
+def draw
+  background 50 
+  box 300, 300, 300
+end
+
+def settings
+  size 600, 600, P3D
+  smooth 8
+end
+```
+
+Alternative Examples: [3D Menger][menger], [Retained Shape][shape], [Constrained ArcBall][constrain]
+
+[menger]: https://github.com/ruby-processing/picrate-examples/blob/master/library/vecmath/vec3d/retained_menger.rb
+[shape]: https://github.com/ruby-processing/picrate-examples/blob/master/library/vecmath/arcball/arcball_shape.rb
+[constrain]: https://github.com/ruby-processing/picrate-examples/blob/master/library/vecmath/arcball/constrain.rb

data/docs/_classes/chooser/chooser.md

@@ -0,0 +1,56 @@
+---
+layout: page
+title:  "File Chooser"
+permalink:   /classes/chooser/
+---
+
+A native file chooser for propane, bases around vanilla processing `selectInput`.
+
+### Usage ###
+
+First load the `chooser` library, this creates the interface:-
+
+`public void file_selected(java.io.File selected);` 
+
+which you need to define in your sketch, to make use the `selected` file. This sketch makes use of the propane method `resizable` (vanilla processing `surface.setResizable(true)`) so that we can change sketch size to match our `image`. Note we need to guard against `img` being `nil` or sketch will crash. You may change the the prompt `select an image` in `select_input` but you cannot change `file_selected` which is hard-wired to cope with java reflection. 
+
+### example sketch ###
+```ruby
+load_library :chooser
+
+attr_reader :img
+
+def settings
+  size(400, 200)
+end
+
+def setup
+  sketch_title 'Chooser'
+  resizable
+  fill 0, 0, 200
+  text('Click Window to Load Image', 10, 100)
+end
+
+def draw
+  image(img, 0, 0) unless img.nil?
+end
+
+def file_selected(selection)
+  if selection.nil?
+    puts 'Nothing Chosen'
+  else
+    @img = load_image(selection.get_absolute_path)
+    surface.set_size(img.width, img.height)
+  end
+end
+
+def mouse_clicked
+  @img = nil
+  # java_signature 'void selectInput(String, String)'
+  select_input('select an image', 'file_selected')
+end
+```
+
+See more [examples here][examples]
+
+[examples]:https://github.com/ruby-processing/picrate-examples/tree/master/processing_app/library/file_chooser

data/docs/_classes/deglut/deglut.md

@@ -0,0 +1,20 @@
+---
+layout: page
+title:  "Deglut"
+permalink: /classes/deglut/
+---
+
+Deglut is a fast math module that does sin and cos for integer degrees
+
+Methods:-
+```ruby
+# Returns sine from integer degree input (uses look up table)
+DegLut.sin(deg)
+# Returns cosine from integer degree input (uses look up table)
+DegLut.cos(deg)
+```
+
+Example Usages: [Analog Clock][clock], [Function Grapher][grapher]
+
+[clock]: https://github.com/ruby-processing/picrate-examples/blob/master/library/fastmath/clock.rb
+[grapher]: https://github.com/ruby-processing/picrate-examples/blob/master/contributed/grapher.rb

data/docs/_classes/library_proxy/library_proxy.md

@@ -0,0 +1,76 @@
+---
+layout: post
+title:  "LibraryProxy"
+keywords: processing, abstract class, library
+---
+The purpose of the `LibraryProxy` class is to provide access to [processing reflection][library] methods:-
+
+In the sketch we must `load_library :library_proxy` then our ruby library class can inherit from `LibraryProxy` as below, but it must implement all the abstract methods, even if method is empty
+
+```ruby
+class MyClass < LibraryProxy
+  # access to pre, draw, etc
+end
+```
+
+Example sketch:-
+```ruby
+#!/usr/bin/env jruby
+require 'picrate'
+require_relative 'register_send'
+
+class LibraryProxySketch < Processing::App
+
+  # A simple demonstration of vanilla processing 'reflection' methods using
+  # propane :library_proxy. See my_library.rb code for the guts.
+  load_library :library_proxy
+  require_relative 'my_library'
+
+  def settings
+    size 300, 200
+  end
+
+  def setup
+    sketch_title 'Reflection Voodoo Proxy'
+    MyLibrary.new self
+    no_loop
+  end
+
+  def draw
+    fill(0, 0, 200)
+    ellipse(170, 115, 70, 100)
+  end
+end
+
+LibraryProxySketch.new
+```
+my_library.rb
+
+```ruby
+# This class demonstrates how by inheriting from the abstract class LibraryProxy
+# we can access 'pre', 'draw' and 'post' (Note we need a post method even
+# though it is empty)
+class MyLibrary < LibraryProxy
+  attr_reader :app
+
+  def initialize(parent)
+    @app = parent
+  end
+
+  def pre
+    background(100)
+  end
+
+  def draw
+    app.fill(200, 100)
+    app.ellipse(150, 100, 200, 60)
+  end
+
+  def post # required but empty method is fine
+  end
+end
+```
+
+![library_proxy_sketch.rb]({{ site.github.url }}/assets/library_proxy.png)
+
+[library]:https://github.com/processing/processing/wiki/Library-Basics

data/docs/_classes/vec2d/vec2d.md

@@ -0,0 +1,53 @@
+---
+layout: page
+title: "Vec2D"
+permalink: /classes/vec2d/
+---
+
+The Vec2D class is a direct replacement for processings PVector class (when used for 2D work, see Vec3D for 3D version).
+
+### Methods:-
+```ruby
+a * b # where a is instance of Vec2D and b is a scalar
+a + b # where both a and b are both instances of Vec2D
+a - b # where both a and b are both instances of Vec2D
+a / b # where a is instance of Vec2D and b is a scalar
+a == b # where both a and b are both instances of Vec2D
+a.angle_between(b) # where both a and b are both instances of Vec2D
+a.copy # where a is instance of Vec2D returns a deep copy
+a.cross(b) # where both a and b are both instances of Vec2D
+a.dist(b) # where both a and b are both instances of Vec2D
+a.dot(b) # where both a and b are both instances of Vec2D
+a.heading # where a is instance of Vec2D
+a.lerp(b) # where both a and b are both instances of Vec2D
+a.lerp!(b) # where both a and b are both instances of Vec2D
+a.mag # where a is instance of Vec2D
+a.normalize # where a is instance of Vec2D
+a.normalize! # where a is instance of Vec2D
+a.normalize!(b) # where both a and b are both instances of Vec2D
+a.rotate(b) # where both a is an instance of Vec2D and b is scalar radians
+a.rotate!(b) # where both a is an instance of Vec2D and b is scalar radians
+a.set_mag(b) # where both a is instance of Vec2D and b is scalar
+a.set_mag(b) &block # a conditional variantwhere &block evaluates to a boolean
+a.to_a # returns an array [x, y] where a is instance of Vec2D
+a.to_s # returns a string where a is instance of Vec2D
+a.to_vertex(b) # where b is a instance of Render sends vector a to PApplet.vertex
+a.x returns x as a float # where a is instance of Vec2D
+a.x=b # sets the x value of Vec2D a to the float b
+a.y # returns y as a float # where a is instance of Vec2D
+a.y=b # sets the y value of Vec2D a to the float b
+```
+### Constructors:-
+```ruby
+Vec2D.from_angle(a) # returns a new Vec2D object # where a is a float radians
+Vec2D.random # returns a new random Vec2D object # with mag 1.0
+Vec2D.new # returns new instance where x, y are both zero.
+Vec2D.new(a, b) # where a and b are both float or numeric (NB: stored as float)
+Vec2D.new(vec) # where vec has methods `:x` and `:y` that return float or numeric
+```
+
+Note: normalize on zero vector returns a zero vector for simplicities sake (like PVector)
+
+Example Usages: [Examples][Vec2D]
+
+[Vec2D]: https://github.com/ruby-processing/picrate-examples/blob/master/library/vecmath/vec2d/

data/docs/_classes/vec3d/vec3d.md

@@ -0,0 +1,53 @@
+---
+layout: page
+title: "Vec3D"
+permalink: /classes/vec3d/
+---
+
+The Vec3D class is a direct replacement for processings PVector class (when used for 3D work, see Vec2D for 2D version).
+
+### Methods:-
+```ruby
+a * b # where a is instance of Vec3D and b is a scalar
+a + b # where both a and b are both instances of Vec3D
+a - b # where both a and b are both instances of Vec3D
+a / b # where a is instance of Vec3D and b is a scalar
+a == b # where both a and b are both instances of Vec3D
+a.angle_between(b) # where both a and b are both instances of Vec3D
+a.copy # where a is instance of Vec3D returns a deep copy
+a.cross(b) # where both a and b are both instances of Vec3D
+a.dist(b) # where both a and b are both instances of Vec3D
+a.dist_squared(b) # where both a and b are both instances of Vec3D
+a.dot(b) # where both a and b are both instances of Vec3D
+a.mag # where a is instance of Vec3D
+a.mag_squared # where a is instance of Vec3D
+a.normalize # where a is instance of Vec3D
+a.normalize! # where a is instance of Vec3D
+a.set_mag(b) # where a is instance of Vec3D and b is a scalar
+a.set_mag(b) &block # a conditional variant where &block evaluates to a boolean
+a.to_a returns array [x, y, z] # where a is an instance of Vec3D
+a.to_normal(b) # where b is a instance of Render sends vector a to PApplet.normal
+a.to_s # where a is instance of Vec3D
+a.to_vertex(b) # where b is a instance of Render sends vector a to PApplet.vertex
+a.to_vertex_uv(b, u, v) # where b is a instance of Render sends vector a to PApplet.vertex, with float u and v (texture)
+a.x # returns x as a float where a is instance of Vec2D
+a.x = b # sets the x value of Vec3D a to the float b
+a.y # returns y as a float where a is instance of Vec2D
+a.y = b # sets the y value of Vec3D a to the float b
+a.z # returns z as a float where a is instance of Vec2D
+a.z = b # sets the z value of Vec3D a to the float b
+```
+### Constructors:-
+```ruby
+Vec3D.random # returns a new random Vec3D object # with mag 1.0
+Vec3D.new # returns new instance where x, y, z are all zero.
+Vec3D.new(a, b, c) # where a, b & c are float or numeric (NB: stored as float)
+Vec3D.new(vec) # where vec has methods `:x` and `:y` that return float or numeric
+               # if vec has no method `:z` then z is set to zero.
+```
+
+Note: normalize on zero vector returns a zero vector for simplicities sake (like PVector)
+
+Example Usages: [Examples][Vec3D]
+
+[Vec3D]: https://github.com/ruby-processing/picrate-examples/blob/master/library/vecmath/vec3d/

data/docs/_config.yml

@@ -15,16 +15,45 @@ urls:
   wiki: https://github.com/ruby-processing/PiCrate/wiki
 twitter_username: monkstoneT
 github_username:  monkstone
-
-syntax-highlighting:
-  enabled: true
-
-sass:
-  sass_dir: _sass
-
 # Build settings
 markdown: kramdown
 gems:
   - jekyll-sitemap
   - jekyll-feed
   - jekyll-seo-tag
+
+include: [collections]
+collections:
+  blocks:
+    output: true
+    permalink: /blocks/index.html
+  classes:
+    output: true
+    permalink: /classes/index.html
+  editors:
+    output: true
+    permalink: /editors/index.html
+  methods:
+    output: true
+    permalink: /methods/index.html
+  gems:
+    output: true
+    permalink: /gems/index.html
+  libraries:
+    output: true
+    permalink: /libraries/index.html
+  modules:
+    output: true
+    permalink: /modules/index.html
+  magic:
+    output: true
+    permalink: /magic/index.html
+  objects:
+    output: true
+    permalink: /objects/index.html
+
+syntax-highlighting:
+  enabled: true
+
+sass:
+  sass_dir: _sass

data/docs/_editors/vim.md

@@ -0,0 +1,63 @@
+---
+layout: post
+title:  "Vim"
+permalink: /editors/vim/
+keywords: editor, ide, ruby, picrate, vim, emacs, jedit
+---
+
+Is an excellent choice for linux and mac users, it is lighweight (runs from the console) commands available from vim:-
+```bash
+:!jruby %   # will run the sketch
+```
+
+### Live coding with Pry ###
+
+```bash
+jgem install pry
+# or jruby -S gem install pry
+# or if you must use rvm or rbenv not recommended
+```
+Do `echo "Pry.config.editor = 'vim'" > ~/.pryrc` to set vim as the pry editor.
+
+Fire up pry using
+
+```bash
+jruby -e "require 'pry'; binding.pry"
+```
+
+Or more conveniently create a shortcut by using `jpry` alias in your `.bashrc` or equivalent eg `.profile` debian linux:-
+
+```bash
+alias jpry="jruby -e \"require 'pry'; binding.pry\""
+```
+
+At the pry prompt:-
+
+```ruby
+load 'my_sketch'
+```
+
+Creating `my_sketch` is a easy as `picrate -c my_sketch 300 300`
+
+To get full listing of sketch in pry enter `$` at the prompt, to edit the `draw` method at the prompt do:-
+
+```bash
+edit -p MySketch#draw
+```
+
+On finished save and quit `:wq` (or `:wqa` to save all changed buffers) sketch will redraw reflecting changes, but you can repeat:-
+
+```bash
+edit -p MySketch#draw
+```
+
+this allows you to edit your changes which are saved in a `.tmp` file. Read more about vim / emacs integration [here][pry-wiki]
+
+### Other advantages of vim ###
+
+Also because vim is run from the console it is so easy to run old friends like `rubocop` or `reek` on your sketch code.
+
+If you are millenial and allergic to the command line install use an editor that supports ruby syntax, emacs is only for hardcore geeks. As yet I don't think the raspberrypi supports `atom` as an editor.
+
+[atom]:{{ site.github.url }}/atom/
+[pry-wiki]:https://github.com/pry/pry/wiki/Editor-integration/

data/docs/_gems/gems/gems.md

@@ -0,0 +1,29 @@
+---
+layout: post
+title:  "Gems Built For picrate"
+date:   2015-11-21 20:55:13
+categories: picrate update
+keywords: gem, library, picrate
+permalink: gems/gems.html
+---
+
+### Processing libraries ported as ruby-gems
+
+[arcball][arcball], [toxiclibs][tox], [geomerative][geom], [wordcram][wordcram]
+
+NB: the arcball gem is installed as a picrate dependency
+
+### Other java libraries ported as ruby-gems
+
+jbox2d ([pbox2d][jbox2d])
+
+### Stand Alone Gems
+[cf3][cf3] context free art in ruby
+
+[cf3]:https://github.com/monkstone/cf3ruby/
+[arcball]:https://github.com/ruby-processing/ArcBall/
+[tox]:https://github.com/ruby-processing/toxicgem/
+[geom]:https://ruby-processing.github.io/geomerativegem/
+[jbox2d]:https://github.com/ruby-processing/jbox2d/
+[cf3]:https://github.com/monkstone/cf3ruby/
+[wordcram]:https://ruby-processing.github.io/WordCram/