Basic Hair Example SunflowAPIAPI just using jruby

It occurred to me that all I was getting from using ruby-processing in my previous post was the ruby processing interface to the libraries. So here is the straightforward jruby version....
Screen output very much as before (smaller) hence not included there. For your convenience I present an embedded gist (click on view raw to copy).
See previous post for how to setup java libraries.
Example translated from java version (by Christopher Warnow?) included in the subversion checkout of the sunflowAPIAPI.

	# hair.rb NB: run this script directly with jruby
	require 'library/sunflow_api/library/sunflow_api.jar'
	require 'library/sunflow/library/sunflow.jar'
	require 'library/sunflow/library/janino.jar'
	class BasicHair
	API = Java::Com::briansteen::SunflowAPIAPI
	SMath = Java::Org::sunflow::math
	JColor = java.awt.Color
	attr_reader :width, :height, :n_particles, :sunflow
	def initialize width = 640, height = 480
	@width = width
	@height = height
	@n_particles = 20
	# create a new API instance
	@sunflow = API.new
	# set width and height
	@sunflow.set_width(width)
	@sunflow.set_height(height)
	# set background color
	@sunflow.set_background(1, 1, 1)
	# set camera
	@sunflow.set_camera_position(0, 7, 5)
	@sunflow.set_camera_target(2, 0.5, 0)
	@sunflow.set_thinlens_camera("thinLensCamera", 50, width/height)
	# set basic light
	@sunflow.set_point_light("myPointLight", SMath::Point3.new(0, 5, 5),
	JColor.new(255, 255, 255))
	@sunflow.set_directional_light("myDirectionalLight", SMath::Point3.new(-2, 3, 0),
	SMath::Vector3.new(0, 0, 0), 3, JColor.new(1, 1, 1))
	# @sunflow.setSphereLight("mySphereLight", SMath::Point3.new(0, 30, -5),
	# JColor.new(0, 0, 255), 32, 10)
	# draw a ground plane
	@sunflow.draw_plane("ground", SMath::Point3.new(0, 0, 0), SMath::Vector3.new(0, 1, 0))
	# coordinates array
	@sunflow.draw_box("boxname", 0, 0, 0, 1)
	end
	def create_scene
	hair_widths = [0.025]
	# create particle coordinates
	350.times do |j|
	# particle start position
	particle_x = Math.cos(j * 0.5) * j * 0.0015
	particle_y = 0
	particle_z = Math.sin(j * 0.5) * j * 0.0015
	hair_coordinates = Array.new(n_particles * 3)
	array_index = -1
	n_particles.times do |i|
	particle_x += 0.1 + Math.cos(i * 0.15 + j * 0.05) * 0.13
	particle_y -= Math.sin(particle_z * 0.01 + j * 0.05) * 0.125 +
	Math.cos(i * 0.5 + particle_y) * 0.125
	particle_z += Math.sin(i) * 0.25 + particle_y * 0.01
	hair_coordinates[array_index += 1] = particle_x
	hair_coordinates[array_index += 1] = particle_y
	hair_coordinates[array_index += 1] = particle_z
	end
	# set ambient occlusion shader
	@sunflow.setAmbientOcclusionShader("myAmbientOcclusionShader#{j}", JColor.new(55, 55, 55),
	JColor.new(0, 0, 0), 16, 1)
	# set glass shader
	# @sunflow.setGlassShader("myGlassShader", JColor.new(1, 1, 1), 2.5, 3, JColor.new(1, 1, 1))
	# set shiny-diffuse shader
	# @sunflow.setShinyDiffuseShader("myShinyShader", JColor.new(55, 55, 55), 0.8)
	# draw object
	@sunflow.draw_hair("hair#{j}", n_particles - 2, hair_coordinates.to_java(:float),
	hair_widths.to_java(:float))
	end
	end
	def render_scene filename = nil
	sunflow.setIrradianceCacheGIEngine(32, 0.4, 1, 15, nil)
	# render
	sunflow.render() unless filename
	if filename
	begin # test for dodgy filename/path
	file = File.new(filename, "w")
	file.close
	sunflow.render(filename) # save as png image
	rescue
	puts "Warning #{filename} is not writable"
	end
	end
	end
	end
	hair = BasicHair.new 200, 200 # NB: render small is useful for quick for checking
	hair.create_scene
	hair.render_scene # default is to render in sunflow frame ie not to file

view raw sunflow_hair.rb hosted with ❤ by GitHub

Basic Hair Example SunflowAPIAPI in ruby processing

See previous post for how to setup java libraries.


# basic_hair.rb run with 'rp5 run script.rb'

class BasicHair < Processing::App
  load_libraries :sunflow_api, :sunflow
  include_package 'com.briansteen'
  include_package 'org.sunflow.math'
  include_package 'java.awt'

  API = Java::Com::briansteen::SunflowAPIAPI
  SMath = Java::Org::sunflow::math
  JColor = java.awt.Color
  WIDTH = 640
  HEIGHT = 480
  P_AMOUNT = 20
       
  def setup
    # create a new API instance
    @sunflow = API.new
    # set width and height
               
    @sunflow.set_width(WIDTH)
    @sunflow.set_height(HEIGHT)
    # set background color
    @sunflow.set_background(1, 1, 1)
    # set camera
    @sunflow.set_camera_position(0, 7, 5)
    @sunflow.set_camera_target(2, 0.5, 0)
    @sunflow.set_thinlens_camera("thinLensCamera", 50, WIDTH/HEIGHT)
    # set basic light
    @sunflow.set_point_light("myPointLight", SMath::Point3.new(0, 5, 5),
    JColor.new(255, 255, 255))
    @sunflow.set_directional_light("myDirectionalLight", SMath::Point3.new(-2, 3, 0),
    SMath::Vector3.new(0, 0, 0), 3, JColor.new(1, 1, 1))
    # @sunflow.setSphereLight("mySphereLight", SMath::Point3.new(0, 30, -5),
    # JColor.new(0, 0, 255), 32, 10)
    # draw a ground plane
    @sunflow.draw_plane("ground", SMath::Point3.new(0, 0, 0), SMath::Vector3.new(0, 1, 0))             
    # coordinates array
    hair_widths = [0.025]              
    @sunflow.draw_box("boxname", 0, 0, 0, 1)           
    # create particle coordinates
    350.times do |j|
      # particle start position
      particle_x = Math.cos(j*0.5)*j*0.0015
      particle_y = 0
      particle_z = Math.sin(j*0.5)*j*0.0015
      hair_coordinates = Array.new(P_AMOUNT*3)
      array_index = -1
      P_AMOUNT.times do |i|
        particle_x += 0.1 + Math.cos(i * 0.15 + j*0.05) * 0.13
        particle_y -= Math.sin(particle_z*0.01 + j*0.05)*0.125 +
        Math.cos(i*0.5 + particle_y)*0.125
        particle_z += Math.sin(i)*0.25 + particle_y*0.01                               
        hair_coordinates[array_index += 1] = particle_x
        hair_coordinates[array_index += 1] = particle_y
        hair_coordinates[array_index += 1] = particle_z
      end
                       
      # set ambient occlusion shader
      @sunflow.setAmbientOcclusionShader("myAmbientOcclusionShader#{j}", JColor.new(55,55,55),
      JColor.new(0,0,0), 16, 1)
      # set glass shader
      # @sunflow.setGlassShader("myGlassShader", JColor.new(1,1,1), 2.5, 3, JColor.new(1,1,1))
      # set shiny-diffuse shader
      # @sunflow.setShinyDiffuseShader("myShinyShader", JColor.new(55,55,55), 0.8)
                       
      # draw object
      @sunflow.drawHair("hair#{j}", P_AMOUNT - 2, hair_coordinates.to_java(:float),
        hair_widths.to_java(:float))
    end
               
    @sunflow.setIrradianceCacheGIEngine(32, 0.4, 1, 15, nil)           
    # render
    @sunflow.render() # display in sunflow window
    # @sunflow.render("BasicHair.png") # save as png image
  end
          
  def draw
   exit
  end 
          
end

SunflowAPIAPI in ruby processing

# sunflow_test.rb

class SunflowTest < Processing::App
  load_libraries :sunflow_api, :sunflow
  include_package 'com.briansteen'
  include_package "org.sunflow.math"
  API = Java::Com::briansteen::SunflowAPIAPI
  SMath = Java::Org::sunflow::math
  WIDTH = 500
  HEIGHT = 500

  def setup
    @sunflow = API.new
    @sunflow.set_width(WIDTH)
    @sunflow.set_height(HEIGHT)
    @sunflow.set_camera_position(0, 2.5, -5)
    @sunflow.set_camera_target(0, 0, 0)
    @sunflow.set_thinlens_camera("thinLensCamera", 50, WIDTH/HEIGHT)
    @sunflow.draw_plane("ground", SMath::Point3.new(0,-3.5,0), SMath::Vector3.new(0, 1, 0))
    @sunflow.draw_sphere_flake("mySphereFlake", 20, SMath::Vector3.new(0, 1, 0), 1)
    @sunflow.setPathTracingGIEngine 6
    @sunflow.render "SunflowTestRender.png"
  end

  def draw
    exit
  end

end

SunflowTest.new :title => "Sunflow Test"






This example was copied from amnon, following his recent posting on the processing discussion boards.

Checkout the sunflowapapi source (created by  Christopher Warnow?) as follows:-
svn checkout http://sunflowapiapi.googlecode.com/svn/trunk/ sunflowapiapi-read-only

Get the sunflow libraries here, NB must be version 0.07.3:-

http://sunflow.sourceforge.net

Or possible here for Windows users:-

http://www.polyquark.com/opensource

The usual library setup required compile and jar the sunflowapiapi code into sunflow_api.jar nest that as follows in a folder library, in a folder sunflow_api in the library folder (in the directory where the sketch you want to run is stored). Do similar for the sunflow.jar put the janino.jar in the same folder.  The janino.jar provides a fast java compiler, version is 2.~ is supplied with the sunflow download, however with a few minor modifications sunflow can be updated to use the latest version 2.6.1 (basically include the commons-compiler.jar, and remove a couple of deprecated exception types from the code and  update the CompileException to the commons compiler version org.codehaus.commons.compiler.CompileException, do this in an ide unless you are crazy).

A Staffordshire Knot Using Ruby Processing and A Context Free Library

A Staffordshire Knot, ruby-processing 3D context-free DSL from monkstone on Vimeo.

Using a slight variation of the previous post we get something similar to the Staffordshire Knot.


segment :rz => i, :ry => Math.sin(i*Math::PI/180)*0.2, :x => Math.sin(i*Math::PI/180)*1.5


Is the main change, although to produce the video, I was saving frames and set the size to 640*480 to match vimeo preferences. Was very jumpy when I saved frames as #####.png ...

I have since uploaded an improved version, this time using the default save_frame (hence tif format). Mencoder doesn't like this format so I batch converted the tif files to png as so:-

mogrify -format png -transparent blue *.tif


See my processing blog for the video recording details.

An Infinity Loop? With My 3D Context Free Library

# infinity.rb
# An 'infinity loop?'

load_libraries :test_free

full_screen

attr_reader :xrot, :yrot, :zrot, :wheel, :col

def setup_the_spiral
  @spiral = ContextFree.define do

    rule :infinity do
      360.times do |i|
      split do
        segment :rz => i, :ry => Math.sin(i*Math::PI/180)*0.2, :x => Math.cos(i*Math::PI/180)*3
      rewind
      end
      end
    end

    rule :segment do                      
      cube :alpha => 0.8
    end
   
    rule :segment do                      
      cube :brightness => 1.0, :saturation => 1.0
    end

  end
end



def setup
  render_mode P3D
  @wheel = JWheelListener.new(-50, -20)      # initialize listener with start_z and maximum values
  self.add_mouse_wheel_listener(wheel)       # register the mouse listener  
  smooth
  @xrot = 0.01
  @yrot = 0
  @zrot = 0
  @col = 0
  setup_the_spiral
end

def draw
  background 0
  setup_lights col
  specular col, 1, 1
  emissive 0.05
  shininess 10
  smooth_rotation(3, 3.2)
  smooth_color(6.0)
  @spiral.render :infinity, :start_x => 0, :start_y => 0, :start_z => wheel.zoom, :size => height/350,
  :stop_size => 0.2, :color => [0, 0.7, 0.7, 0.5], :rx => xrot, :ry => yrot, :rz => zrot
end

##
# Generate a gradient value that changes smoothly over time in the range [ 0, 1 ].
# The Math.sin() function is used to map the current time in milliseconds somewhere
# in the range [ 0, 1 ]. A 'speed' factor is specified by the parameters s1.
#
def smooth_gradient(s1)
  mills = millis * 0.00003   
  gradient = 0.5 * Math.sin(mills * s1) + 0.5
end
 
##
# Rotate the current coordinate system.
# Uses smooth_gradient() to smoothly animate the rotation.
#
def smooth_rotation(s1, s2)    
  @yrot = 2.0 * Math::PI * smooth_gradient(s1)
  @zrot = 2.0 * Math::PI * smooth_gradient(s2)
end

##
# Generate a 'hue' value which smoothly changes over time.
# The speed of change is controlled by the parameter s1.
#
def smooth_color(s1)
  @col = smooth_gradient(s1)
end

def setup_lights(col)   
  directional_light(col, 0.8, 0.8, -0.5, 0.5, -1)
  point_light(col, 0.8, 0.8, -0.5, 0.5, -1)
  ambient_light(col, 0.8, 0.8, 1, 1, 1)
end

Revised 3D Context Free DSL Sketch, with Mouse Wheel Zoom Utility

I demonstrate the new feature of mouse wheel zoom in this sketch. The logic for the smooth of color and rotation I copied from lazydogs classy rotating ball. PS: if you can't see the embedded code below chances are you are not using either Firefox or Google Chrome browser (doesn't always work for me with Opera, which I also find is awkward to use when copying code).

	# A colorful animation of default.es
	# the StructureSynth default script with wheel zoom feature
	load_libraries :test_free
	full_screen
	attr_reader :xrot, :yrot, :zrot, :wheel, :col
	def setup_the_spiral
	@spiral = ContextFree.define do
	rule :default do
	split do
	R1 :brightness => 1
	rewind
	R2 :brightness => 1
	end
	end
	rule :R1 do
	sphere :brightness => 0.8
	R1 :size => 0.99, :x => 0.25, :rz => 6, :ry => 6
	end
	rule :R2 do
	sphere :brightness => 0.8
	R2 :size => 0.99, :x => -0.25, :rz => 6, :ry => 6
	end
	end
	end
	def setup
	render_mode P3D
	@wheel = JWheelListener.new(-50, -20) # initialize listener with start_z and maximum values
	self.add_mouse_wheel_listener(wheel) # register the mouse listener
	smooth
	@xrot = 0.01
	@yrot = 0
	@zrot = 0
	@col = 0
	setup_the_spiral
	end
	def draw
	background 0
	setup_lights col
	specular col, 1, 1
	emissive 0.05
	shininess 10
	smooth_rotation(6.7, 7.3)
	smooth_color(6.0)
	@spiral.render :default, :start_x => 0, :start_y => 0, :start_z => wheel.zoom, :size => height/350,
	:stop_size => 0.2, :color => [0, 0.8, 0.8], :rx => xrot, :ry => yrot, :rz => zrot
	end
	##
	# Generate a gradient value that changes smoothly over time in the range [ 0, 1 ].
	# The Math.sin() function is used to map the current time in milliseconds somewhere
	# in the range [ 0, 1 ]. A 'speed' factor is specified by the parameters s1.
	#
	def smooth_gradient(s1)
	mills = millis * 0.00003
	gradient = 0.5 * Math.sin(mills * s1) + 0.5
	end
	##
	# Rotate the current coordinate system.
	# Uses smooth_gradient() to smoothly animate the rotation.
	#
	def smooth_rotation(s1, s2)
	@yrot = 2.0 * Math::PI * smooth_gradient(s1)
	@zrot = 2.0 * Math::PI * smooth_gradient(s2)
	end
	##
	# Generate a 'hue' value which smoothly changes over time.
	# The speed of change is controlled by the parameter s1.
	#
	def smooth_color(s1)
	@col = smooth_gradient(s1)
	end
	def setup_lights(col)
	directional_light(col, 0.8, 0.8, -0.5, 0.5, -1)
	point_light(col, 0.8, 0.8, -0.5, 0.5, -1)
	ambient_light(col, 0.8, 0.8, 1, 1, 1)
	end

view raw default.rb hosted with ❤ by GitHub

	# A Context-Free library for Ruby-Processing, inspired by
	# contextfreeart.org and StructureSynth
	# Built on Jeremy Ashkenas context free DSL script
	# now extended to provide mouse wheel zoom class
	module Processing
	class ContextFree
	include Processing::Proxy
	attr_accessor :rules, :app, :xr, :yr, :zr
	AVAILABLE_OPTIONS = [:x, :y, :z, :rx, :ry, :rz, :size, :color, :hue, :saturation, :brightness, :alpha]
	HSB_ORDER = {:hue => 0, :saturation => 1, :brightness => 2, :alpha => 3}
	# Define a context-free system. Use this method to create a ContextFree
	# object. Call render() on it to make it draw.
	def self.define(&block)
	cf = ContextFree.new
	cf.instance_eval &block
	cf
	end
	# Initialize a bare ContextFree object with empty recursion stacks.
	def initialize
	@app = $app
	@graphics = $app.g
	@finished = false
	@rules = {}
	@rewind_stack = []
	@matrix_stack = []
	@xr = 0
	@yr = 0
	@zr = 0
	end
	# Create an accessor for the current value of every option. We use a values
	# object so that all the state can be saved and restored as a unit.
	AVAILABLE_OPTIONS.each do |option_name|
	define_method option_name do
	@values[option_name]
	end
	end
	# Here's the first serious method: A Rule has an
	# identifying name, a probability, and is associated with
	# a block of code. These code blocks are saved, and indexed
	# by name in a hash, to be run later, when needed.
	# The method then dynamically defines a method of the same
	# name here, in order to determine which rule to run.
	def rule(rule_name, prob=1, &proc)
	@rules[rule_name] ||= {:procs => [], :total => 0}
	total = @rules[rule_name][:total]
	@rules[rule_name][:procs] << [(total...(prob+total)), proc]
	@rules[rule_name][:total] += prob
	unless ContextFree.method_defined? rule_name
	self.class.class_eval do
	eval <<-METH
	def #{rule_name}(options)
	merge_options(@values, options)
	pick = determine_rule(#{rule_name.inspect})
	@finished = true if @values[:size] < @values[:stop_size]
	unless @finished
	get_ready_to_draw
	pick[1].call(options)
	end
	end
	METH
	end
	end
	end
	# Rule choice is random, based on the assigned probabilities.
	def determine_rule(rule_name)
	rule = @rules[rule_name]
	chance = rand * rule[:total]
	pick = @rules[rule_name][:procs].select {|the_proc| the_proc[0].include?(chance) }
	return pick.flatten
	end
	# At each step of the way, any of the options may change, slightly.
	# Many of them have different strategies for being merged.
	def merge_options(old_ops, new_ops)
	return unless new_ops
	# Do size first
	old_ops[:size] *= new_ops[:size] if new_ops[:size]
	new_ops.each do |key, value|
	case key
	when :size
	when :x, :y, :z
	old_ops[key] = value * old_ops[:size]
	when :rz, :ry, :rx
	old_ops[key] = value * (Math::PI / 180.0)
	when :hue, :saturation, :brightness, :alpha
	adjusted = old_ops[:color].dup
	adjusted[HSB_ORDER[key]] *= value
	old_ops[:color] = adjusted
	when :width, :height
	old_ops[key] *= value
	when :color
	old_ops[key] = value
	else # Used a key that we don't know about or trying to set
	merge_unknown_key(key, value, old_ops)
	end
	end
	end
	# Using an unknown key let's you set arbitrary values,
	# to keep track of for your own ends.
	def merge_unknown_key(key, value, old_ops)
	key_s = key.to_s
	if key_s.match(/^set/)
	key_sym = key_s.sub('set_', '').to_sym
	if key_s.match(/(brightness|hue|saturation|alpha)/)
	adjusted = old_ops[:color].dup
	adjusted[HSB_ORDER[key_sym]] = value
	old_ops[:color] = adjusted
	else
	old_ops[key_sym] = value
	end
	end
	end
	# Doing a 'split' saves the context, and proceeds from there,
	# allowing you to rewind to where you split from at any moment.
	def split(options=nil, &block)
	save_context
	merge_options(@values, options) if options
	yield
	restore_context
	end
	# Saving the context means the values plus the coordinate matrix.
	def save_context
	@rewind_stack.push @values.dup
	@matrix_stack << @graphics.get_matrix
	end
	# Restore the values and the coordinate matrix as the recursion unwinds.
	def restore_context
	@values = @rewind_stack.pop
	@graphics.set_matrix @matrix_stack.pop
	end
	# Rewinding goes back one step.
	def rewind
	@finished = false
	restore_context
	save_context
	end
	# Render the is method that kicks it all off, initializing the options
	# and calling the first rule.
	def render(rule_name, starting_values={})
	@values = {:x => 0, :y => 0, :z => 0,
	:rz => 0, :ry => 0, :rx => 0,
	:size => 1, :width => 1, :height => 1,
	:start_x => 0, :start_y => 0, :start_z => 0,
	:color => [0.5, 0.5, 0.5, 1],
	:stop_size => 1.5}
	@values.merge!(starting_values)
	@finished = false
	@app.reset_matrix
	@app.no_stroke
	@app.color_mode HSB, 1.0
	@app.translate @values[:start_x], @values[:start_y], @values[:start_z]
	self.send(rule_name, {})
	end
	# Before actually drawing the next step, we need to move to the appropriate
	# location.
	def get_ready_to_draw
	@app.translate(@values[:x], @values[:y], @values[:z])
	@app.rotate_x(@values[:rx])
	@app.rotate_y(@values[:ry])
	@app.rotate_z(@values[:rz])
	end
	# Compute the rendering parameters for drawing a shape.
	def get_shape_values(some_options)
	old_ops = @values.dup
	merge_options(old_ops, some_options) if some_options
	@app.fill *old_ops[:color]
	return old_ops[:size], old_ops
	end
	# The primitive shapes are sphere and cube
	def cube(some_options=nil)
	size, options = *get_shape_values(some_options)
	rotz = options[:rz]
	roty = options[:ry]
	rotx = options[:rx]
	@app.rotate_x rotx unless rotx.nil?
	@app.rotate_y roty unless roty.nil?
	@app.rotate_z rotz unless rotz.nil?
	@app.translate(options[:x] * size, options[:y] * size , options[:z] * size)
	@app.box(size)
	@app.rotate_z(-1 * rotz) unless rotz.nil? # unwind rotations in an ordered way
	@app.rotate_y(-1 * roty) unless roty.nil?
	@app.rotate_x(-1 * rotx) unless rotx.nil?
	end
	def sphere(some_options=nil)
	size, options = *get_shape_values(some_options)
	rotz = options[:rz]
	roty = options[:ry]
	rotx = options[:rx]
	@app.rotate_x rotx unless rotx.nil?
	@app.rotate_y roty unless roty.nil?
	@app.rotate_z rotz unless rotz.nil?
	@app.translate(options[:x] * size, options[:y] * size, options[:z] * size)
	@app.sphere_detail 10
	@app.sphere(size)
	@app.rotate_z(-1 * rotz) unless rotz.nil? # unwind rotations in an ordered way
	@app.rotate_y(-1 * roty) unless roty.nil?
	@app.rotate_x(-1 * rotx) unless rotx.nil?
	end
	end
	# JWheelListener class enables the use mouse wheel to say zoom sketch
	class JWheelListener
	include java.awt.event.MouseWheelListener
	attr_reader :zoom, :max
	# zoom is the initial value (for say z_start)
	# limit range of zoom with max
	def initialize(zoom, max)
	@zoom = zoom
	@max = max
	end
	def mouse_wheel_moved(e)
	increment = e.get_wheel_rotation * 5 # increment/decrement
	@zoom = ((zoom < max)||(increment < 0))? zoom + increment : zoom
	end
	end
	end

view raw test_free.rb hosted with ❤ by GitHub

default.rb from monkstone on Vimeo.

A Mouse Wheel Listener in Ruby Processing

For my 3D context free application/library, I would like to be able to zoom using the mouse wheel, I had vaguely thought about using peasycam or proscene to provide that, and other functionality. In the first instance I wanted to create it myself. After a bit of research, this the sort of implementation I would do using the java classes/interfaces in ruby:-

# mouse_listener.rb

class JWheelListener
  include java.awt.event.MouseWheelListener

  attr_reader :zoom

  def initialize(zoom)
    @zoom = zoom
  end

  def mouse_wheel_moved(e)
    @zoom += e.get_wheel_rotation * 10
  end

end

class Mouse < Processing::App

  attr_reader :wheel

  def setup
    size(1000, 1000)
    @wheel = JWheelListener.new(10)
    self.add_mouse_wheel_listener(@wheel)  
  end

  def draw
    background 0
    fill 255, 0, 0
    ellipse(width/2, height/2, wheel.zoom, wheel.zoom)

  end

end

Mouse.new :title => "Mouse Wheel Listener"

3D Context Free DSL Screen Saver?

Here is an animated version of the default.es from StructureSynth in ruby-processing. Mac or windows users might want to experiment with OPENGL rendering, as this sketch exposes errors in processing P3D, I see odd missing pixels from time to time. If you don't like the holes remove the smooth, personally I prefer the holes to the glitchty non-smooth (it is a known issue with current versions of processing with both P2D and P3D renderers, something to do with tessellation algorithms).  The test_free library is as in previous post.
Nest the library as follows:-
library/test_free/test_free.rb in the folder containing the sketch
For instructions for installing ruby-processing follow the first link in the blog header.


# full_screen.rb
# An animation of default.es
# the StructureSynth default script

load_libraries :test_free
full_screen
attr_reader :xrot, :yrot, :zrot

def setup_the_spiral
  @spiral = ContextFree.define do

    rule :default do
      split do
      R1 :brightness => 1
      rewind
      R2 :brightness => 1
    end
    end

    rule :R1 do                      
      sphere :brightness => 1
      R1 :size => 0.99, :x => 0.25, :rz => 6, :ry => 6
    end

    rule :R2 do                      
      sphere :brightness => 1
      R2 :size => 0.99, :x => -0.25, :rz => 6, :ry => 6
    end

  end
end

def setup
  render_mode P3D
  smooth
  @xrot = 0.01
  @yrot = 0
  @zrot = 0
  setup_the_spiral
end

def draw
  background 0
  lights
  smooth_rotation(6.7, 7.3)
  @spiral.render :default, :start_x => 0, :start_y => 0, :start_z => -50, :size => height/350,
  :stop_size => 0.2, :color => [0, 0.8, 0.8], :rx => xrot, :ry => yrot, :rz => zrot
end

##
# Generate a vector whose components change smoothly over time in the range [ 0, 1 ].
# Each component uses a Math.sin() function to map the current time in milliseconds somewhere
# in the range [ 0, 1 ].A 'speed' factor is specified for each component.
#
def smooth_vector(s1, s2)
  mills = millis * 0.00003
  y = 0.5 * Math.sin(mills * s1) + 0.5
  z = 0.5 * Math.sin(mills * s2) + 0.5
  vec = [y, z]
end

##
# Rotate the current coordinate system.
# Uses smooth_vector() to smoothly animate the rotation.
#
def smooth_rotation(s1, s2)
  r1 = smooth_vector(s1, s2)
  @yrot = (2.0 * Math::PI * r1[0])
  @zrot = (2.0 * Math::PI * r1[1])
end

Translating the default.es to ruby processing DSL

It was very constructive to see if I could translate the EisenScript to my ruby processing DSL, I immediately learnt something about the EisenScript (recursion seems to be implicit, something I had not understood before). What I learnt about my library, was I was losing some context by directly altering the attitude (the image expected from the EisenScript appeared briefly but quickly degraded). I have now re-factored the sketch to only adjust the initial angle, the x rotation seems to affect the amplitude of deformation from the plane of the spirals. The y and z rotation give control of the attitude, and need to be used in combination to fully explore the 3 dimensional shape, which is now somewhat like that produced by StrucureSynth. 

Here is my revised 3d context free DSL (test_free.rb):-

# A Context-Free library for Ruby-Processing, inspired by
# contextfreeart.org and StructureSynth
# Built on Jeremy Ashkenas context free DSL script

module Processing

  class ContextFree


    include Processing::Proxy

    attr_accessor :rules, :app, :xr, :yr, :zr

    AVAILABLE_OPTIONS = [:x, :y, :z, :rx, :ry, :rz, :size, :color, :hue, :saturation, :brightness, :alpha]
    HSB_ORDER         = {:hue => 0, :saturation => 1, :brightness => 2, :alpha => 3}

    # Define a context-free system. Use this method to create a ContextFree
    # object. Call render() on it to make it draw.
    def self.define(&block)
      cf = ContextFree.new
      cf.instance_eval &block
      cf
    end


    # Initialize a bare ContextFree object with empty recursion stacks.
    def initialize
      @app          = $app
      @graphics     = $app.g
      @finished     = false
      @rules        = {}
      @rewind_stack = []
      @matrix_stack = []
      @xr = 0
      @yr = 0
      @zr = 0
    end


    # Create an accessor for the current value of every option. We use a values
    # object so that all the state can be saved and restored as a unit.
    AVAILABLE_OPTIONS.each do |option_name|
      define_method option_name do
        @values[option_name]
      end
    end


    # Here's the first serious method: A Rule has an
    # identifying name, a probability, and is associated with
    # a block of code. These code blocks are saved, and indexed
    # by name in a hash, to be run later, when needed.
    # The method then dynamically defines a method of the same
    # name here, in order to determine which rule to run.
    def rule(rule_name, prob=1, &proc)
      @rules[rule_name] ||= {:procs => [], :total => 0}
      total = @rules[rule_name][:total]
      @rules[rule_name][:procs] << [(total...(prob+total)), proc]
      @rules[rule_name][:total] += prob
      unless ContextFree.method_defined? rule_name
        self.class.class_eval do
          eval <<-METH
            def #{rule_name}(options)
              merge_options(@values, options)
              pick = determine_rule(#{rule_name.inspect})
              @finished = true if @values[:size] < @values[:stop_size]
              unless @finished
                get_ready_to_draw
                pick[1].call(options)
              end
            end
          METH
        end
      end
    end


    # Rule choice is random, based on the assigned probabilities.
    def determine_rule(rule_name)
      rule = @rules[rule_name]
      chance = rand * rule[:total]
      pick = @rules[rule_name][:procs].select {|the_proc| the_proc[0].include?(chance) }
      return pick.flatten
    end


    # At each step of the way, any of the options may change, slightly.
    # Many of them have different strategies for being merged.
    def merge_options(old_ops, new_ops)
      return unless new_ops
      # Do size first
      old_ops[:size] *= new_ops[:size] if new_ops[:size]
      new_ops.each do |key, value|
        case key
        when :size
        when :x, :y, :z
          old_ops[key] = value * old_ops[:size]
        when :rz, :ry, :rx
          old_ops[key] = value * (Math::PI / 180.0)
        when :hue, :saturation, :brightness, :alpha
          adjusted = old_ops[:color].dup
          adjusted[HSB_ORDER[key]] *= value
          old_ops[:color] = adjusted
        when :width, :height
          old_ops[key] *= value
        when :color
          old_ops[key] = value
        else # Used a key that we don't know about or trying to set
          merge_unknown_key(key, value, old_ops)
        end
      end
    end


    # Using an unknown key let's you set arbitrary values,
    # to keep track of for your own ends.
    def merge_unknown_key(key, value, old_ops)
      key_s = key.to_s
      if key_s.match(/^set/)
        key_sym = key_s.sub('set_', '').to_sym
        if key_s.match(/(brightness|hue|saturation|alpha)/)
          adjusted = old_ops[:color].dup
          adjusted[HSB_ORDER[key_sym]] = value
          old_ops[:color] = adjusted
        else
          old_ops[key_sym] = value
        end
      end
    end

    # Doing a 'split' saves the context, and proceeds from there,
    # allowing you to rewind to where you split from at any moment.
    def split(options=nil, &block)
      save_context
      merge_options(@values, options) if options
      yield
      restore_context
    end

    # Saving the context means the values plus the coordinate matrix.
    def save_context
      @rewind_stack.push @values.dup
      @matrix_stack << @graphics.get_matrix
    end

    # Restore the values and the coordinate matrix as the recursion unwinds.
    def restore_context
      @values = @rewind_stack.pop
      @graphics.set_matrix @matrix_stack.pop
    end

    # Rewinding goes back one step.
    def rewind
      @finished = false
      restore_context
      save_context
    end

    # Render the is method that kicks it all off, initializing the options
    # and calling the first rule.
    def render(rule_name, starting_values={})
      @values = {:x => 0, :y => 0, :z => 0,
                 :rz => 0, :ry => 0, :rx => 0,
                 :size => 1, :width => 1, :height => 1,
                 :start_x => width/2, :start_y => height/2, :start_z => 0,
                 :color => [0.5, 0.5, 0.5, 1],
                 :stop_size => 1.5}
      @values.merge!(starting_values)
      @finished = false
      @app.reset_matrix
      @app.no_stroke
      @app.color_mode HSB, 1.0
      @app.translate @values[:start_x], @values[:start_y], @values[:start_z]
      self.send(rule_name, {})
    end

    def rotate_x rt
      @xr = rt
    end
    def rotate_y rt
      @yr = rt
    end
    def rotate_z rt
      @zr = rt
    end

    # Before actually drawing the next step, we need to move to the appropriate
    # location.
    def get_ready_to_draw
      @app.translate(@values[:x], @values[:y], @values[:z])
      @app.rotate_x(@values[:rx] + xr)
      @app.rotate_y(@values[:ry] + yr)
      @app.rotate_z(@values[:rz] + zr)
    end


    # Compute the rendering parameters for drawing a shape.
    def get_shape_values(some_options)
      old_ops = @values.dup
      merge_options(old_ops, some_options) if some_options
      @app.fill *old_ops[:color]
      return old_ops[:size], old_ops
    end


    # Sphere, cube are the primitive drawing
    def cube(some_options=nil)
      size, options = *get_shape_values(some_options)
      rotz = options[:rz]
      roty = options[:ry]
      rotx = options[:rx]
      @app.rotate_x rotx unless rotx.nil?
      @app.rotate_y roty unless roty.nil?
      @app.rotate_z rotz unless rotz.nil?
      @app.translate(options[:x]  * size, options[:y] * size , options[:z]  * size)
      @app.box(size)
      @app.rotate_z(-1 * rotz) unless rotz.nil?  # unwind rotations in an oredered way
      @app.rotate_y(-1 * roty) unless roty.nil?
      @app.rotate_x(-1 * rotx) unless rotx.nil?    
  
    end


    def sphere(some_options=nil)
      size, options = *get_shape_values(some_options)
      rotz = options[:rz]
      roty = options[:ry]
      rotx = options[:rx]
      @app.rotate_x rotx unless rotx.nil?
      @app.rotate_y roty unless roty.nil?
      @app.rotate_z rotz unless rotz.nil?
      @app.sphere_detail 10
      @app.sphere(size)
      @app.rotate_z(-1 * rotz) unless rotz.nil?  # unwind rotations in an oredered way
      @app.rotate_y(-1 * roty) unless roty.nil?
      @app.rotate_x(-1 * rotx) unless rotx.nil?    
    end
  end
end





My Translation of default.es to ruby processing



# default.rb
# virtually a direct translation of default.es
# the StructureSynth default script

load_libraries :test_free, :control_panel

attr_reader :amplitude, :yrot, :zrot

def setup_the_spiral
  @spiral = ContextFree.define do

    rule :default do
      split do
      R1 :brightness => 1
      rewind
      R2 :brightness => 1
    end
    end

    rule :R1 do                      
      sphere :brightness => 1
      R1 :size => 0.99, :x => 0.25, :rz => 6, :ry => 6
    end

    rule :R2 do                      
      sphere :brightness => 1
      R2 :size => 0.99, :x => -0.25, :rz => 6, :ry => 6
    end

  end
end

def configure_control # setup control panel gui
  control_panel do |c|
    c.title = "Amplitude+Attitude"
    c.slider :amplitude, -0.025..0.015, 0.0
    c.slider :yrot, -6.3..6.3, 0.005
    c.slider :zrot, -6.3..6.3, 0.005
  end
end

def setup
  size 800, 800, P3D
  configure_control
  smooth
  setup_the_spiral
end

def draw
  background 0
  lights
  @spiral.render :default, :start_x => 0, :start_y => 0, :start_z => -40, :size => height/400,
  :stop_size => 0.2, :color => [0, 0.8, 0.8], :rx => amplitude, :ry => yrot, :rz => zrot
end

Testing the cube primitive in my context free DSL

Another context free DSL example, better annotated, control panel and library as previous post (not shown):-


# cube.rb

load_libraries :test_free, :control_panel

attr_reader :xrot, :yrot, :zrot

def setup_the_spiral
  @spiral = ContextFree.define do  # define the cf rules
   
    rule :cubeform do
      5.times do |i|
        split do                   # record the context
        cuby :ry => 72 * i
        rewind                     # restore the context
        end
      end
    end

    rule :beam do                      
       6.times do |i|
        split do                    # record the context
          cube :y => 0.2 * i
        rewind                      # restore the context
        end
      end
    end
 
    rule :cuby do
      beam :brightness => 1
      cuby :size => 0.98, :y => -0.24  # recursive call ends when size < 1
    end

  end
end

def setup              # static setup
  size 800, 800, P3D   # I can only use P3D (unless full_screen) on linux opengl might work on mac/windows
  configure_control
  smooth
  setup_the_spiral
end

def configure_control # setup control panel gui
  control_panel do |c|
    c.title = "Attitude Control"
    c.slider :xrot, -3.1..3.1, 0.5
    c.slider :yrot, -3.1..3.1, 0.5
    c.slider :zrot, -3.1..3.1, 1.0
  end
end

def draw             # animation loop    
  background 0.8     
  lights
  @spiral.render :cubeform, :start_x => 0, :start_y => 10, :start_z => -30, :size => height/300, :stop_size => 1, :color => [0, 0.8, 0.8]
  @spiral.rotate_x xrot
  @spiral.rotate_y yrot
  @spiral.rotate_z zrot   
end

 


Within the sketch :hue, :saturation and :brightness can be individually set. If you want to use :alpha, initialize :color with a 4 dimension array. Note, the color mode in the ruleset is hsb with range 0 .. 1.0. Increment and decrement is linear cf size where it is multiplicative.