picrate 0.0.2-java → 0.0.3-java

data/docs/_methods/color.md

@@ -0,0 +1,109 @@
+---
+layout: post
+title:  "color explained"
+permalink: methods/color.html
+---
+### processing ###
+The `*.pde` files get pre-processed to `java` before compiling, allowing you to write this:-
+
+```java
+color c2 = #FFCC00; // this gets pre-processed to `int c2 = 0xffFFCC00`
+```
+This is yet another vanilla `processing` convention that you must learn to get around once you leave the processing ide.
+
+### propane  / JRubyArt ###
+
+in ruby we instead support use of quoted web-string (string is at least a valid type in ruby and java)
+
+```ruby
+c2 = color('#FFCC00') # we return a signed java int, note quoted string
+```
+
+For propane we enable a convenience method color (based on processing PGraphics color), and for the most part this method behaves as the processing color method (but it is implemented differently under the hood to work with ruby Numeric/Fixnum). Basically the input can be an Array of Fixnum (approximating to a processing int) an Array of Float (approximating to processing float) or a special hexadecimal string or a hexadecimal number. See / try example sketch.
+
+```ruby
+
+#!/usr/bin/env jruby -w
+# frozen_string_literal: true
+# Creating Colors (Homage to Albers).
+#
+require 'picrate'
+
+# Creating variables for colors that may be referred to
+# in the program by their name, rather than a number.
+class CreatingColors < Processing::App
+  attr_reader :redder, :yellower, :orangish
+  WEB = %w(#CC6600 #CC9900 #993300)
+
+  def settings
+    size 640, 360
+  end  
+
+  def setup
+    sketch_title 'Homage to Albers'
+    palette = web_to_color_array(WEB)
+    @redder = palette[0]
+    @yellower = palette[1]
+    @orangish = palette[2]
+    # These statements are equivalent to the statements above.
+    # Programmers may use the format they prefer.
+
+    # hex color as a String (NB quotes are required)
+    @redder = palette[0]
+    @yellower = palette[1]
+    @orangish = palette[2]
+
+    # @redder = color '#CC6600'
+    # @yellower = color '#CC9900'
+    # @orangish = color '#993300'
+
+    # or alternatively as a hexadecimal
+
+    # @redder = color 0xFFCC6600
+    # @yellower = color 0xFFCC9900
+    # @orangish = color 0xFF993300
+    puts int_to_ruby_colors(palette)
+  end
+
+  def draw
+    no_stroke
+    background 51, 0, 0
+    push_matrix
+    translate 80, 80
+    fill orangish
+    rect 0, 0, 200, 200
+    fill yellower
+    rect 40, 60, 120, 120
+    fill redder
+    rect 60, 90, 80, 80
+    pop_matrix
+    push_matrix
+    translate 360, 80
+    fill redder
+    rect 0, 0, 200, 200
+    fill orangish
+    rect 40, 60, 120, 120
+    fill yellower
+    rect 60, 90, 80, 80
+    pop_matrix
+  end
+end
+
+```
+
+### Making Necessity into a Virtue ###
+
+Many vanilla processing libraries (eg Hype, Wordcram and ColorHarmony) make use of the vanilla processing conventions to define `web` colors. But we have gone one better in JRubyArt and propane to use ruby to quickly create arrays of `web` color and even `dictionaries` of `web` colors. Now such lists would be useless unless we could convert the `web` colors to valid `color` int for use in processing as we have with the [web_to_color_array][web] method.
+
+```ruby
+WEB = %w(#CC6600 #CC9900 #FFFFFF).freeze
+web_to_color_array(WEB)
+# output = [-3381760, -3368704, -1]
+```
+
+For creation and use of a hash / dictionary of web colors see this [Wordcram sketch][wordcram]. If you need to convert an array of `color` int (say from ColorHarmony) to ruby string, then use `p52ruby` method that returns a web string of the form '%w(#CC6600 #CC9900 #FFFFFF)' from `[-3381760, -3368704, -1]`. Or if you are more sophisticated and using the `toxiclibs` gem to explore color theory, we have created a method `to_ruby_string` for the `ColorList` class see [palette genertor example][palette]
+
+[palette]:https://github.com/ruby-processing/picrate-examples/blob/master/gems/toxiclibs/color_utils/palette_generator.rb
+[wordcram]:https://github.com/ruby-processing/picrate-examples/blob/master/gems/ruby_wordcram/fruits.rb
+[web]:{{site.github.url}}/summary/
+[processing]:https://processing.org/reference/color_datatype.html

data/docs/_methods/data_path.md

@@ -0,0 +1,109 @@
+---
+layout: post
+title:  "data_path"
+date:   2016-05-23 05:04:00
+categories: picrate update
+permalink: methods/data_path.html
+---
+The purpose of the `data_path` wrapper is to provide the absolute data path to a sketches `data` folder. In vanilla processing the direct use of this method is discouraged, owing to the way it has been implemented (it is used internally and may be the cause file access issues in PiCrate). The `data_path` method is implemented in PiCrate, and does not rely on the vanilla-processing version.
+
+It should be used to get around the need to provide an absolute data path on macosx to run sketches that contain `load_image`, `load_shader` etc that otherwise could not find the data.
+
+### Simple usage ###
+
+```ruby
+#!/usr/bin/env jruby -w
+require 'picrate'
+class LoadImage < Processing::App
+  def setup
+    sketch_title 'Load Image'
+    # The file "jelly.jpg" must be in the data folder
+    # of the current sketch to load successfully
+    @a = load_image(data_path('jelly.jpg'))
+    no_loop # Makes draw only run once
+  end
+
+  def draw
+    image @a, 0, 0
+    image @a, @a.width, 0, @a.width / 2, @a.height / 2
+  end
+
+  def settings
+    size 300, 200
+  end
+end
+
+LoadImage.new
+```
+
+NB: it is equally valid to use `data_path` to provide an absolute path to the data folder on save (even when the data folder needs to be created on save).
+
+### More sophisticated usage ###
+You can use your ruby knowledge to 'dry up' vanilla processing sketches and to remove the need to type `data_path` many times in a sketch. Please note that we cannot rely on JRuby to convert an array of ruby-string to an array of java-string, this is why we need `glsl_files.to_java(:string)`. However the array of images does not require such an explicit conversion, _JRuby generally just does the right thing_.
+
+```ruby
+#!/usr/bin/env jruby -w
+require 'picrate'
+# Earth model with bump mapping, specular texture and dynamic cloud layer.
+# Adapted from the THREE.js tutorial to processing by Andres Colubri,
+# translated to PiCrate by Martin Prout:
+# http://learningthreejs.com/blog/2013/09/16/how-to-make-the-earth-in-webgl/
+class BlueMarble < Processing::App
+  attr_reader :earth, :clouds, :earth_shader, :cloud_shader, :earth_rotation
+  attr_reader :clouds_rotation, :target_angle
+
+  SHADERS = %w(EarthFrag.glsl EarthVert.glsl CloudFrag.glsl CloudVert.glsl).freeze
+  SHADER_NAME = %i(earth_frag earth_vert cloud_frag cloud_vert).freeze
+  IMAGES = %w(earthmap1k earthcloudmap earthcloudmaptrans earthbump1k earthspec1k).freeze
+  IMAGE_NAME = %i(earth_tex cloud_tex alpha_tex bump_map spec_map).freeze
+
+  def setup
+    sketch_title 'Blue Marble'
+    @earth_rotation = 0
+    @clouds_rotation = 0
+    glsl_files = SHADERS.map { |shade| data_path(shade) }
+    shaders = SHADER_NAME.zip(glsl_files.to_java(:string)).to_h
+    images = IMAGES.map { |img| load_image(data_path("#{img}.jpg")) }
+    textures = IMAGE_NAME.zip(images).to_h
+    @earth_shader = load_shader(shaders[:earth_frag], shaders[:earth_vert])
+    earth_shader.set('texMap', textures[:earth_tex])
+    earth_shader.set('bumpMap', textures[:bump_map])
+    earth_shader.set('specularMap', textures[:spec_map])
+    earth_shader.set('bumpScale', 0.05)
+    @cloud_shader = load_shader(shaders[:cloud_frag], shaders[:cloud_vert])
+    cloud_shader.set('texMap', textures[:cloud_tex])
+    cloud_shader.set('alphaMap', textures[:alpha_tex])
+    @earth = create_shape(SPHERE, 200)
+    earth.setStroke(false)
+    earth.setSpecular(color(125))
+    earth.setShininess(10)
+    @clouds = create_shape(SPHERE, 201)
+    clouds.setStroke(false)
+  end
+
+  def draw
+    background(0)
+    translate(width / 2, height / 2)
+    point_light(255, 255, 255, 300, 0, 500)
+    target_angle = map1d(mouse_x, (0..width), (0..TWO_PI))
+    @earth_rotation += 0.05 * (target_angle - earth_rotation)
+    shader(earth_shader)
+    push_matrix
+    rotate_y(earth_rotation)
+    shape(earth)
+    pop_matrix
+    shader(cloud_shader)
+    push_matrix
+    rotate_y(earth_rotation + clouds_rotation)
+    shape(clouds)
+    pop_matrix
+    @clouds_rotation += 0.001
+  end
+
+  def settings
+    size(600, 600, P3D)
+  end
+end
+
+BlueMarble.new
+```

data/docs/_methods/draw.md

@@ -0,0 +1,20 @@
+---
+layout: post
+title:  "draw"
+permalink: methods/draw.html
+---
+Called directly after setup, the draw function continuously executes the lines of code contained inside its block until the program is stopped or no_loop is called. The number of times draw executes in each second may be controlled with the frame_rate(xxx).
+
+It is common to call background near the beginning of the [draw loop][draw] to clear the contents of the window. Since pixels drawn to the window are cumulative, omitting background may result in unintended results, especially when drawing anti-aliased shapes or text.
+
+There can only be one [draw][draw] function for each sketch, and [draw][draw] must exist if you want the code to run continuously, or to process events such as [mouse_pressed][mouse_pressed].
+
+```ruby
+def draw
+  background 0
+  # dynamic code
+end
+```
+
+[draw]:https://processing.org/reference/draw_.html
+[mouse_pressed]:https://processing.org/reference/mousePressed_.html

data/docs/_methods/key_pressed.md

@@ -0,0 +1,27 @@
+---
+layout: post
+title:  "key_pressed"
+permalink: methods/key_pressed.html
+---
+In vanilla processing [keyPressed][keyPressed] is both a variable and a method, for PiCrate the boolean variable is available as `key_pressed?`, whereas you can create events/operations that occur on key pressed by adding a `key_pressed` method as below:-
+
+```ruby
+def key_pressed  
+  # code gets executed on key pressed you can access the `key` variable in this loop
+  case key
+  when 'c', 'C'
+  # do stuff when c is pressed
+end
+```
+
+For sketch with `key_pressed` method see [raining][raining], follow link for a sketch using [key_pressed?][key_pressed?] or this [alternative][alternative].
+
+See also:-
+
+[key_released][keyReleased]
+
+[key_pressed?]:https://github.com/ruby-processing/picrate-examples/blob/master/basics/typography/letters.rb
+[keyPressed]:https://processing.org/reference/keyPressed_.html
+[keyReleased]:https://processing.org/reference/keyReleased_.html
+[raining]:https://github.com/ruby-processing/picrate-examples/blob/master/demos/raining.rb
+[alternative]:https://github.com/ruby-processing/picrate-examples/blob/master/demos/25_squares.rb

data/docs/_methods/library_loader.md

@@ -0,0 +1,49 @@
+---
+layout: post
+title:  "load_library"
+keywords: ruby, java, jruby, library, load_library, native
+permalink: methods/load_library.html
+---
+The purpose of the `load_library` (synonym `load_libraries`) method is to provide a convenient way to load the different kinds of ruby [libraries][libraries], and in the case of java libraries that use a native library, load the relevant classpath.  It does this by a mixture of pattern matching and honest magic so that you don't need to worry about adding the native libraries to classpath to the java runtime, and lots of other incomprehensible stuff. When it works it is fabulous (which is most of the time on Linux64 bit and MacOS). See examples under [libraries][libraries].
+
+### Cautionary Notes ###
+
+Simply loading in the code for a library via `load_library` may not be enough to actually import the library's classes into your namespace. For some libraries, such as __Minim__, you'll want to import the package as well (as you would in Java):
+
+```ruby
+load_library 'minim'
+java_import 'ddf.minim'
+java_import 'ddf.minim.analysis'
+include_package 'ddf' # can also be use to "import the ddf package"
+```
+
+ Some libraries use Java's reflective capacities to try and invoke methods on your sketch. If the methods that they're looking for happen to be defined in Ruby alone, Java won't be able to find them. Better support for this sort of thing may be forthcoming in a future JRuby releases, but for now you'll either need to patch the library to stop using [reflection][reflection] on the sketch, or insert a thin Java interface. For example, the [Carnivore][carnivore] library uses reflection and tries to find a `packetEvent()` method on the sketch. An appropriate fix is to create, compile and jar-up a java interface, and then include it into your sketch. See also how we implement a native [FileChooser][magic] (_reflection can be a pain, and unfortunately those processing guys seem to be dead keen on it_).
+
+```java
+public interface PacketListener {
+ public void packetEvent(org.rsg.carnivore.CarnivorePacket packet);  
+}
+```
+
+Compile it, jar it up.
+
+<pre>
+javac -cp path/to/carnivore.jar PacketListener.java
+jar cvf packet_listener.jar PacketListener.java
+</pre>
+
+And then include it in your sketch...
+
+```ruby
+require 'packet_listener'
+include Java::PacketListener
+
+def packetEvent(packet)
+  # code goes here...
+end
+```
+
+[libraries]:{{ site.github.url }}/libraries.html
+[carnivore]:http://r-s-g.org/carnivore/installation.html
+[magic]:{{ site.github.url }}/magic/processing
+[reflection]:https://docs.oracle.com/javase/tutorial/reflect/

data/docs/_methods/map1d.md

@@ -0,0 +1,77 @@
+---
+layout: post
+title:  "map1d in detail"
+permalink: methods/map1d.html
+---
+
+### Name ###
+
+`map1d` _NB: a different was used than vanilla processing because `map` has another meaning in ruby and we anticipate a possible `map2d` or even `map3d`_.
+
+### Examples ###
+
+```ruby
+#!/usr/bin/env jruby -w
+require 'picrate'
+class UsingMap1D < Processing::App
+  def settings
+    size(200, 200)
+  end
+
+  def setup
+    sketch_title 'Using map1d'
+    no_stroke
+  end
+
+  def draw
+    background(204)
+    x1 = map1d(mouse_x, (0..width), (50..150))
+    ellipse(x1, 75, 50, 50)
+    x2 = map1d(mouse_x, (0..width), (0..200))
+    ellipse(x2, 125, 50, 50)
+  end
+end
+
+UsingMap1D.new
+```
+
+### Description	###
+
+Re-maps a number from one range to another.
+
+As shown in the example, numbers outside of the range are not clamped to the minimum and maximum parameters values, because out-of-range values are often intentional and useful.
+
+### Syntax ###
+
+```ruby
+map1d(value, (start1..stop1), (start2..stop2))
+```
+
+### Parameters ###
+
+value	the incoming value to be converted
+
+start1 lower bound of the value's current range
+
+stop1	upper bound of the value's current range
+
+start2	lower bound of the value's target range
+
+stop2 upper bound of the value's target range
+
+Returns	float
+
+### Related ###
+
+`constrained_map` (numbers are clamped to range)
+
+`p5map` (same signature as [processing map][map])
+
+`norm` (same as [processing norm][norm])
+
+`norm_strict` (output is clamped to 0..1.0)
+
+`lerp`
+
+[norm]:https://processing.org/reference/norm_.html
+[map]:https://processing.org/reference/map_.html

data/docs/_methods/methods_summary.md

@@ -0,0 +1,103 @@
+---
+layout: post
+title:  "summary"
+permalink: methods/summary.html
+---
+
+The MathTool and HelperMethods modules implement some of the processing convenience methods
+
+### color method
+A convenience method that returns a 'color' int for processing
+
+```ruby
+color(*args)           # where args can be a hex string, a hexadecimal number, etc. see examples
+color('#CC6600')       # hexadecimal string, can be lower-case
+color(0xFFCC6600)      # hexadecimal
+color(255)             # white
+color(0)               # black
+color(255, 0, 0)       # red
+color(0, 0, 255)       # blue
+color(0, 0, 255, 100)  # blue with alpha value 100
+```
+Example Usages: [Creating][color], [Blend Color][blend_color]
+
+### hsb_color method
+A convenience method that returns a 'color' int for processing for `hsb` input, where hue, saturation and brightness are in range `0..1.0`
+
+```ruby
+hsb_color(hue, sat, bright) # where args are ruby float
+```
+
+### web_to_color_array method
+A convenience method that converts an array of web color strings to an array of 'color' int. Particularly useful when working with the Joshua Davis Processing-HYPE library.
+```ruby
+WEB = %w(#CC6600 #CC9900 #FFFFFF).freeze
+web_to_color_array(WEB)
+# output = [-3381760, -3368704, -1]
+```
+see usage in a [Wordcram sketch][wordcram]
+
+### p52ruby
+
+A convenience method that converts an array of 'color' int to a ruby string that you can use in your Wordcram or Hype sketches (say from a ColorHarmony sketch)
+
+```ruby
+p52ruby([-3381760, -3368704, -1])
+# output = "%w(#CC6600 #CC9900 #FFFFFF)\n"
+```
+For toxiclibs we have created a new method `to_ruby_string` for the `ColorList` class that does the same thing for a collection of `TColor`
+See this [toxiclibs sketch][palette] where we use color theory to generate a sketch palette.
+
+### map1d method
+A replacement for processings map function, maps val (range1) to range2 using a linear transform.
+
+```ruby
+map1d(val, range1, range2) # where val is an input float range1 is source and range2 is target
+# simple example
+map1d(10, (0..20), (0..1.0)) # returns 0.5
+```
+
+Example Usages: [Mandelbrot][mandelbrot], [Game of Life][conway]
+
+### radians and degrees methods
+A replacement for processings radians(x) and degree(x) methods _in ruby everything is an object!!_
+
+```ruby
+x.radians # we did this by monkey patching ruby numeric
+x.degrees
+```
+
+Note: ruby already provides x.abs, x.to_s, and x.to_f replacing abs(x), str(x), and float(x) etc
+
+Example Usages:
+[bezier ellipse][bezier], [brick tower][brick_tower]
+
+### Processing max and min convenience methods
+
+We make these methods available in propane, by mocking them using ruby `Enumerable` `max` and `min` methods, you may prefer to use the `Enumerable` methods directly since they are more flexible (you can even provide a [comparator block][enumerable] to change basis of ordering).
+
+
+### find_method method
+A convenient way of finding a method
+
+```ruby
+find_method(method) # where method is a method name or fragment
+# simple example
+puts find_method('map') # see output below
+```
+
+```bash
+constrained_map
+map1d
+p5map
+```
+
+[palette]:https://github.com/ruby-processing/picrate-examples/blob/master/gems/toxiclibs/color_utils/palette_generator.rb
+[wordcram]:https://github.com/ruby-processing/picrate-examples/blob/master/gems/ruby_wordcram/fruits.rb
+[bezier]:https://github.com/ruby-processing/picrate-examples/blob/master//basics/form/bezier_ellipse.rb
+[brick_tower]:https://github.com/ruby-processing/picrate-examples/blob/master//basics/form/brick_tower.rb
+[mandelbrot]:https://github.com/ruby-processing/JRubyArt-examples/blob/master/contributed/mandelbrot.rb
+[conway]:https://github.com/ruby-processing/picrate-examples/blob/master//topics/shaders/conway.rb
+[color]:https://github.com/ruby-processing/picrate-examples/blob/master//basics/color/creating.rb
+[blend_color]:https://github.com/ruby-processing/picrate-examples/blob/master//basics/color/blend_color.rb
+[enumerable]:http://apidock.com/ruby/Enumerable/max

data/docs/_methods/mouse_pressed.md

@@ -0,0 +1,25 @@
+---
+layout: post
+title:  "mouse_pressed"
+permalink: methods/mouse_pressed.html
+---
+In vanilla processing [mousePressed][mousePressed] is both a variable and a method, for PiCrate the boolean variable is available as `mouse_pressed?`, whereas you can create events/operations that occur on mouse pressed by adding a [mouse_pressed][mouse_pressed] method as below:-
+
+```ruby
+def mouse_pressed  
+  # code gets executed on mouse pressed
+end
+```
+
+For sketch with mouse_pressed method see [drawolver][drawolver], follow link for a sketch using [mouse_pressed?][mouse_pressed?].
+
+See also:-
+
+[mouse_released][mouse_released], [mouse_dragged][mouse_dragged], [mouse_clicked][mouse_clicked]
+
+[mouse_pressed?]:https://github.com/ruby-processing/JRubyArt-examples/blob/master/basics/input/mouse_press.rb
+[mousePressed]:https://processing.org/reference/mousePressed_.html
+[drawolver]:https://github.com/ruby-processing/picrate-examples/blob/master/demos/drawolver.rb
+[mouse_released]:https://github.com/ruby-processing/picrate-examples/blob/master/demos/bezier_playground.rb
+[mouse_dragged]:https://github.com/ruby-processing/picrate-examples/blob/master/demos/bezier_playground.rb
+[mouse_clicked]:https://github.com/ruby-processing/picrate-examples/blob/master/demos/fibonacci_sphere.rb

data/docs/_methods/post_initialize.md

@@ -0,0 +1,9 @@
+---
+layout: post
+title:  "post_initialize"
+permalink: methods/post_initialize.html
+---
+We have provided a `post_initialize` for a propane sketch, which allows you to send parameter options to your sketch via initialize, and really only makes sense when you explicitly create an instance of your sketch. The `post_initialize` method is a hook that avoids you needing to call super on initialize. At present we haven't got an examples to show you, but see this is an alternative
+[hook example][hook].
+
+[hook]:https://github.com/ruby-processing/picrate-examples/tree/master/processing_app/topics/ruby_hook

data/docs/_methods/processing_api.md

@@ -0,0 +1,46 @@
+---
+layout: post
+title:  "processing API"
+permalink: methods/processingapi.html
+---
+Most of the processing methods, as explained in the [Processing Language API][api], are available as instance methods to the Processing::App. (frame_rate, ellipse, many others).  But there are [exceptions][alternatives] see below and [here][alternatives], where good or better alternatives already exist in ruby. Also make sure you take a look at the many [included example sketches][sketches], where ruby [core][core] and [Math][Math] methods are preferred over the processing/java alternative eg `rand(0.0..4)` is preferred over `random(0, 4.0)`.
+
+```ruby
+#!/usr/bin/env jruby -w
+require 'picrate'
+class TrianglesGoneWild < Processing::App
+  def settings
+    size 600, 600
+    smooth 8
+  end
+
+  def setup
+    sketch_title 'Triangles Gone Wild'
+    color_mode RGB, 1.0
+    frame_rate 30
+    fill 0.8, 0.6
+  end
+
+  def draw
+    triangle(rand(width), rand(height), rand(width), rand(height), rand(width), rand(height))
+  end
+end
+
+TrianglesGoneWild.new
+```
+
+Some variables that you might expect to find under their Processing names are available by more rubyish names, `keyPressed` becomes `key_pressed?` and `mousePressed` becomes `mouse_pressed?`. The functions `keyPressed`, `mousePressed` become `key_pressed` and `mouse_pressed` ie without `?`. And some things are better done with regular Ruby than with Processing; instead of using `load_strings('file.txt')` to read in a file, consider `File.readlines('file.txt')`. For math use `x.to_f`, `x.radians` and `x**3` for `float(x)`, `radians(x)` and `pow(x, 3)`.
+
+Because of this method madness, `Processing::App` has a convenience method for searching through them. `find_method('ellipse')` will return a list of the method names that may match what you're looking for: 'ellipse', 'ellipseMode', and 'ellipse_mode'. Please note this is an instance method, so from irb or pry use `Propane.app.find_method 'ellipse'` on a loaded sketch. Alternatively add `puts find_method 'ellipse'` at the end of your `setup` method (or `draw` but only with `no_loop`).
+
+Also prefer [`Vec2D`][vec2] and [`Vec3D`][vec3] to [`PVector`][pvector] follow links for reference. Also you can/should use `data_path` to wrap filenames (propane uses ruby to access the absolute_path of files in the sketch data folder, this avoids the file permission issues of the vanilla-processing method).
+
+[api]:https://processing.org/reference/index.html
+[vec2]:{{site.github.url}}/classes/vec2d/
+[vec3]:{{site.github.url}}/classes/vec3d/
+[alternatives]:{{site.github.url}}/methods/alternative_methods/
+[pvector]:https://processing.org/reference/PVector.html
+[Math]:https://ruby-doc.org/core-2.2.3/Math.html
+[core]:https://ruby-doc.org/core-2.2.3/
+[sketches]:https://github.com/ruby-processing/JRubyArt-examples/
+[settings]:https://processing.org/reference/settings_.html

data/docs/_methods/settings.md

@@ -0,0 +1,48 @@
+---
+layout: post
+title:  "settings"
+permalink: methods/settings.html
+---
+All sketches require a user defined [settings][settings] method. This is where you define the sketch size (can be fullscreen) and render mode. Regular processing sketches hide this in a pre-process step that converts `pde` code to valid java code (on linux you can find the java code in the `/tmp` folder, and in some other temporary location on MacOS and Windows).
+
+Minimal code default renderer:-
+```ruby
+def settings
+  size 200, 200
+end
+```
+
+Minimal code fullscreen default renderer:-
+```ruby
+def settings
+  fullscreen
+end
+```
+
+Minimal code fullscreen opengl 3D renderer:-
+```ruby
+def settings
+  size 200, 200, P3D
+end
+```
+
+Minimal code fullscreen opengl 3D renderer:-
+```ruby
+def settings
+  fullscreen P3D
+end
+```
+
+For hi-dpi screens:-
+
+```ruby
+def settings
+  size 200, 200
+  pixel_density(2)
+end
+```
+
+You should also put `smooth` inside [settings][settings]
+
+NB: as with vanilla-processing you can access the `width` and `height` variables within the sketch, eg in draw loop or mouse_pressed.
+[settings]:https://processing.org/reference/settings_.html

data/docs/_methods/setup.md

@@ -0,0 +1,36 @@
+---
+layout: post
+title:  "setup"
+permalink: methods/setup.html
+---
+All sketches will propably have a user defined [setup][setup] method. This is where you define the sketch title and where static code belongs.
+
+```ruby
+def setup
+  sketch_title 'My sketch'
+  # ... static code
+end
+```
+
+ Note to make variables declared in setup in the rest of sketch, you can make use of ruby `attr_reader` as for the `pts` array below.
+
+```ruby
+attr_reader :pts
+
+ def setup
+   sketch_title 'My sketch'
+   @pts = []
+   # ... static code
+ end
+ ```  
+
+ When the you can access `pts` in say the draw loop
+
+ ```ruby
+ def draw
+   p pts.length
+   # ... static code
+ end
+ ```  
+
+[settings]:https://processing.org/reference/setup_.html