ruby-processing 1.0.11 → 2.4.1

data/samples/anar/l_system.rb

@@ -1,86 +0,0 @@
-# Demonstrates how you can use the Lindenmeyer System (lsys)
-# features of the Anar library in Ruby-Processing.
-# Press space to draw further iterations of the system.
-
-load_libraries 'anar', 'opengl'
-import "anar"
-import "lsys.Grammar"
-import "processing.opengl"
-full_screen
-
-def setup
-  setup_opengl
-  Anar.init self
-  Anar.draw_axis true
-  create_grammar
-  create_scene
-end
-
-def create_grammar
-  @grammar = Grammar.new("bt")
-  # Here we define the rules.
-  # "*" means any kind of symbol.
-  # The example rules below are non-contextual.
-  @grammar.add_rule("*b*", "brb")
-  @grammar.add_rule("*t*", "rssb")
-  @grammar.add_rule("*r*", "rs")
-  @grammar.add_rule("*s*", "s")
-  # The following rule makes it context-sensitive.
-  #	grammar.add_rule("sss", "ss")
-  puts @grammar
-end
-
-def create_scene
-  @box    = Box.new(10, 10, 50)                     # the base element
-  @pos    = Translate.new(0, 50, 0)                 # with position
-  @trans  = Translate.new(Anar.Pt(0, 10, -0.001))   # and transformations...
-  @rot    = RotateZ.new(0.5)
-  @scale  = Scale.new(Anar.Pt(0.99, 0.99, 0.99))
-  interpret_grammar
-end
-
-def interpret_grammar
-  @scene = Obj.new
-  @root  = Transform.new(@pos)
-  @grammar.num_of_symbols.times do |i|
-    rule = @grammar.symbol(i)[0].chr
-    case rule # todo this is bit of hack, I need understand grammar better
-    when 'b'
-      @scene.add(Obj.new(@box, @root))
-      @root = Transform.new(@root)
-    when 't' then @root.apply(@trans)
-    when 'r' then @root.apply(@rot)
-    when 's' then @root.apply(@scale)
-    else
-      puts "rule: '#{rule}' is not in grammar"
-    end
-  end
-  Anar.cam_target @scene
-end
-
-def draw
-  background 153
-  @scene.draw
-end
-
-def key_pressed
-  case key
-  when ' '
-    @grammar.step
-    interpret_grammar
-    puts @grammar
-  when 'r'
-    @grammar.reset
-    create_grammar
-    interpret_grammar
-    puts @grammar
-  when 'p'
-    save_frame "block.png"
-  end
-end
-
-def setup_opengl
-  render_mode OPENGL
-  hint ENABLE_OPENGL_4X_SMOOTH     # optional
-  hint DISABLE_OPENGL_ERROR_REPORT # optional
-end

data/samples/anar/many_shapes.rb

@@ -1,98 +0,0 @@
-# Demonstrates custom shapes with the Anar library.
-# Hold down middle button to control orientation
-# of the working surface (prepare to be amazed)!
-
-load_libraries 'anar', 'opengl'
-import "anar"
-import "processing.opengl"
-full_screen
-
-def setup
-  setup_opengl
-  Anar.init self
-  Anar.draw_axis
-  Face.globalRender = RenderFaceNormal.new(OogColor.new(255, 100), OogColor.new(100))
-  create_shapes
-end
-
-def create_shapes
-  @scene = Obj.new
-  @group = Group.new
-  shapes = []
-
-  # A Cone.
-  cone = Cone.new(50,100,20)
-  cone.set("cone")
-  cone.translate(100,100,0)
-  @group.add(cone)
-  shapes << cone
-  # puts(cone.to_obj_exporter)
-
-  # A Box.
-  box = Box.new(10,20,30)
-  box.set("box")
-  box.rotate_z(0)
-  box.rotate_x(0)
-  box.translate(100, 0, 0)
-  @group.add(box)
-  shapes << box
-  # puts(box.to_obj_exporter("box"))
-  # puts(box.parent_list(-1))
-
-  # A Cylinder
-  cylinder = Cylinder.new(50, 24, 50)
-  cylinder.set("cylinder")
-  cylinder.translate(-100, 0, 0)
-  @group.add(cylinder)
-  shapes << cylinder
-  # puts(cylinder.to_obj_exporter("cylinder"))
-
-  # An ellipse.
-  ellipse = Ellipse.new(40, 20)
-  ellipse.set("ellipse")
-  @group.add(ellipse)
-  shapes << ellipse
-  # puts(ellipse.to_obj_exporter("ellipse"))
-
-  # A 3D Swiss Cross.
-  swiss_cross = SwissCross3D.new(10, 10)
-  swiss_cross.set("swiss_cross")
-  #swiss_cross.fill(255,0,0,200)
-  #swiss_cross.translate(-100,0,0)
-  @group.add(swiss_cross)
-  shapes << swiss_cross
-  # puts(swiss_cross.to_obj_exporter("swiss_cross"))
-
-  # A Revolver
-  control_line = Pts.new()
-  control_line.add(Anar.Pt(30,0,30))
-  control_line.add(Anar.Pt(10,0,40))
-  control_line.add(Anar.Pt(20,0,60))
-  control_line.add(Anar.Pt(20,0,70))
-  revolver = Revolve.new(control_line, Anar.Pt(0,0,20), 12)
-  revolver.set("revolver")
-  @group.add(revolver)
-  shapes << revolver
-  # puts(revolver.to_obj_exporter("revolver"))
-
-  # Add all the shapes to the scene.
-  shapes.each {|shape| @scene.add(shape) }
-  Anar.sliders(swiss_cross)
-  Anar.sliders(revolver)
-  Anar.cam_target(revolver)
-end
-
-def setup_opengl
-  render_mode OPENGL
-  hint ENABLE_OPENGL_4X_SMOOTH     # optional
-  hint DISABLE_OPENGL_ERROR_REPORT # optional
-end
-
-def draw
-  background 155
-  @group.draw
-end
-
-def key_pressed
-  create_shapes if key == ' '
-end

data/samples/peasy_cam/data/java_args.txt

@@ -1 +0,0 @@
--Xms256m -Xmx256m

data/samples/peasy_cam/hilbert_fractal.rb

@@ -1,40 +0,0 @@
-########################################################
-# A 3D Hilbert fractal implemented using a
-# Lindenmayer System in ruby-processing by Martin Prout
-# Best if you've got opengl
-########################################################
-
-class Hilbert_Test < Processing::App
-  full_screen # NB: All distances are relative to screen height
-  load_libraries 'hilbert', 'PeasyCam', 'opengl'
-  import 'peasy'
-  import "processing.opengl" if library_loaded? "opengl"
-  attr_reader :hilbert, :cam
-
-  def setup
-    library_loaded?(:opengl) ? configure_opengl : render_mode(P3D)
-    configure_peasycam
-    @hilbert = Hilbert.new(height)
-    hilbert.create_grammar 3
-    no_stroke
-  end
-
-  def configure_peasycam
-    cam = PeasyCam.new self, height / 6.5
-    cam.set_minimum_distance height / 10
-    cam.set_maximum_distance height
-  end
-
-  def configure_opengl
-    render_mode OPENGL
-    hint ENABLE_OPENGL_4X_SMOOTH     # optional
-    hint DISABLE_OPENGL_ERROR_REPORT # optional
-  end
-
-  def draw
-    background 0
-    lights
-    hilbert.render
-  end
-end
-

data/samples/processing_app/3D/camera/move_eye.rb

@@ -1,29 +0,0 @@
-# Move Eye. 
-# by Simon Greenwold.
-# 
-# The camera lifts up (controlled by mouseY) while looking at the same point.
-
-class MoveEye < Processing::App
-
-  def setup
-    size 640, 360, P3D
-    fill 204
-  end
-  
-  def draw
-  	lights
-  	background 0
-  	
-  	camera 30, mouseY, 220, 0, 0, 0, 0, 1, 0
-  	
-  	noStroke
-  	box 90
-  	stroke 255
-  	line( -100, 0, 0, 100, 0, 0)
-  	line( 0, -100, 0, 0, 100, 0)
-  	line( 0, 0, -100, 0, 0, 100)
-  end
-  
-end
-
-MoveEye.new :title => "Move Eye"

data/samples/processing_app/3D/camera/ortho_vs_perspective.rb

@@ -1,38 +0,0 @@
-# Click to see the difference between orthographic projection
-# and perspective projection as applied to a simple box.
-# The ortho function sets an orthographic projection and 
-# defines a parallel clipping volume. All objects with the 
-# same dimension appear the same size, regardless of whether 
-# they are near or far from the camera. The parameters to this 
-# function specify the clipping volume where left and right 
-# are the minimum and maximum x values, top and bottom are the 
-# minimum and maximum y values, and near and far are the minimum 
-# and maximum z values.
-
-def setup
-  size 640, 360, P3D
-  no_stroke
-  fill 204
-end
-
-def draw
-  background 0
-  lights
-  
-  mouse_pressed? ? show_perspective : show_orthographic
-  
-  translate width/2, height/2, 0
-  rotate_x -PI/6
-  rotate_y PI/3
-  box 160
-end
-
-def show_perspective
-  fov = PI/3.0
-  camera_z = (height/2.0) / tan(PI * fov / 360.0)
-  perspective fov, width.to_f/height.to_f, camera_z/2.0, camera_z*2.0
-end
-
-def show_orthographic
-  ortho -width/2, width/2, -height/2, height/2, -10, 10
-end

data/samples/processing_app/3D/form/brick_tower.rb

@@ -1,86 +0,0 @@
-# Original by Ira Greenberg
-
-# 3D castle tower constructed out of individual bricks.
-# Uses the PVecor and Cube classes.
-
-def setup
-  @bricks_per_layer = 16
-  @brick_layers = 18
-  @brick_width, @brick_height, @brick_depth = 60, 25, 25
-  @radius = 175.0
-  @angle = 0
-  size 640, 360, P3D
-  @brick = Cubeish.new(@brick_width, @brick_height, @brick_depth)
-end
-
-def draw
-  background 0
-  @temp_x, @temp_y, @temp_z = 0, 0, 0
-  fill 182, 62, 29
-  no_stroke
-  lights
-  translate(width/2.0, height*1.2, -380)                  # move viewpoint into position
-  rotate_x(radians(-45))                                  # tip tower to see inside
-  rotate_y(frame_count * PI/600)                          # slowly rotate tower
-  @brick_layers.times {|i| draw_layer(i) }
-end
-
-def draw_layer(layer_num)
-  @layer_num = layer_num
-  @temp_y -= @brick_height                                # increment rows
-  @angle = 360.0 / @bricks_per_layer * @layer_num / 2.0   # alternate brick seams
-  @bricks_per_layer.times {|i| draw_bricks(i) }
-end
-
-def draw_bricks(brick_num)
-  @brick_num = brick_num
-  @temp_z = cos(radians(@angle)) * @radius
-  @temp_x = sin(radians(@angle)) * @radius
-  push_matrix
-  translate @temp_x, @temp_y, @temp_z
-  rotate_y(radians(@angle))
-  top_layer = @layer_num == @brick_layers - 1
-  even_brick = @brick_num % 2 == 0
-  @brick.create unless top_layer                          # main tower
-  @brick.create if top_layer && even_brick                # add crenelation
-  pop_matrix
-  @angle += 360.0 / @bricks_per_layer
-end
-
-
-# The Cubeish class works a little different than the cube in the
-# Processing example. SIDES tells you where the negative numbers go.
-# We dynamically create each of the PVectors by passing in the
-# appropriate signs.
-class Cubeish
-  SIDES = {:front  => ['-- ', ' - ', '   ', '-  '],
-           :left   => ['-- ', '---', '- -', '-  '],
-           :right  => [' - ', ' --', '  -', '   '],
-           :back   => ['---', ' --', '  -', '- -'],
-           :top    => ['-- ', '---', ' --', ' - '],
-           :bottom => ['-  ', '- -', '  -', '   ']}
-
-  SIGNS = {'-' => -1,
-           ' ' =>  1}
-
-  def initialize(width, height, depth)
-    @vertices = {}
-    @w, @h, @d = width, height, depth
-
-    SIDES.each do |side, signs|
-      @vertices[side] = signs.map do |s|
-        s = s.split('').map {|el| SIGNS[el] }
-        App::PVector.new(s[0]*@w/2, s[1]*@h/2, s[2]*@d/2)
-      end
-    end
-  end
-
-  def create
-    @vertices.each do |name, vectors|
-      begin_shape App::QUADS
-      vectors.each {|v| vertex(v.x, v.y, v.z) }
-      end_shape
-    end
-  end
-
-end

data/samples/processing_app/3D/form/cubic_grid.rb

@@ -1,51 +0,0 @@
-# Cubic Grid 
-# by Ira Greenberg. 
-# 
-# 3D translucent colored grid uses nested pushMatrix()
-# and popMatrix() functions. 
-
-class CubicGrid < Processing::App
-
-  def setup
-    size 640, 360, P3D
-    no_stroke
-    
-    @box_size = 40
-    @margin = @box_size * 2
-    @depth = 400
-  end
-  
-  def draw
-  	background 255
-  	
-  	translate width/2, height/2, -@depth
-  	rotate_x frame_count * 0.01
-  	rotate_y frame_count * 0.01
-  	
-  	((-@depth/2 + @margin)..(@depth/2 - @margin)).step( @box_size ) { |i|
-  		push_matrix
-  		
-  		((-height + @margin)..(height - @margin)).step( @box_size ) { |j|
-  			push_matrix
-  			
-  			((-width + @margin)..(width - @margin)).step( @box_size ) { |k|
-  				box_fill = color i.abs, j.abs, k.abs, 50
-  				push_matrix
-  				
-  				translate k, j, i
-  				fill box_fill
-  				box @box_size
-  				
-  				pop_matrix
-  			}
-  			
-  			pop_matrix
-  		}
-  		
-  		pop_matrix
-  	}
-  end
-  
-end
-
-CubicGrid.new :title => "Cubic Grid"

data/samples/processing_app/3D/form/rgb_cube.rb

@@ -1,88 +0,0 @@
-# RGB Cube.
-# 
-# The three primary colors of the additive color model are red, green, and blue.
-# This RGB color cube displays smooth transitions between these colors. 
-
-class RgbCube < Processing::App
-
-  def setup
-    size 640, 360, P3D
-    
-    no_stroke
-    color_mode RGB, 2
-
-	@xmag = 0
-	@ymag = 0
-	@new_xmag = 0
-	@new_ymag = 0
-	
-	# since each point is used three times
-	@box_points = {
-		:top_front_left 	=> [-1,  1,  1],
-		:top_front_right 	=> [ 1,  1,  1],
-		:top_back_right 	=> [ 1,  1, -1],
-		:top_back_left 		=> [-1,  1, -1],
-		:bottom_front_left 	=> [-1, -1,  1],
-		:bottom_front_right	=> [ 1, -1,  1],
-		:bottom_back_right	=> [ 1, -1, -1],
-		:bottom_back_left 	=> [-1, -1, -1]
-	}
-	# a box from defined points
-	@box = {
-		:top 	=> [@box_points[:top_front_left], 	 @box_points[:top_front_right], 	@box_points[:top_back_right], 	  @box_points[:top_back_left]],
-		:front 	=> [@box_points[:top_front_left], 	 @box_points[:top_front_right], 	@box_points[:bottom_front_right], @box_points[:bottom_front_left]],
-		:left 	=> [@box_points[:top_front_left], 	 @box_points[:bottom_front_left], 	@box_points[:bottom_back_left],   @box_points[:top_back_left]],
-		:back	=> [@box_points[:top_back_left], 	 @box_points[:top_back_right], 		@box_points[:bottom_back_right],  @box_points[:bottom_back_left]],
-		:right	=> [@box_points[:top_back_right], 	 @box_points[:bottom_back_right], 	@box_points[:bottom_front_right], @box_points[:top_front_right]],
-		:bottom => [@box_points[:bottom_front_left], @box_points[:bottom_front_right],  @box_points[:bottom_back_right],  @box_points[:bottom_back_left]]
-	}
-  end
-  
-  def draw
-  
-  	background 1
-  	
-  	push_matrix
-  	
-  	translate width/2, height/2, -30
-  	
-  	@new_xmag = mouseX / width.to_f * TWO_PI
-  	@new_ymag = mouseY / height.to_f * TWO_PI
-  	
-  	diff = @xmag - @new_xmag
-  	@xmag -= diff / 4 if diff.abs > 0.01
-  	
-  	diff = @ymag - @new_ymag
-  	@ymag -= diff / 4 if diff.abs > 0.01
-  	
-  	rotate_x -@ymag
-  	rotate_y -@xmag
-  	
-  	scale 90
-  	
-  	begin_shape QUADS
-  	
-  	[:top, :front, :left, :back, :right, :bottom].each { |s|
-  		@box[s].each { |p|
-  			fill_from_points p
-  			vertex_from_points p
-  		}
-  	}
-  	
-  	end_shape
-  	
-  	pop_matrix
-  
-  end
-  
-  def fill_from_points ( points )
-  	fill points[0] + 1, points[1] + 1, points[2] + 1 # "+1" translates -1,1 to 0,2
-  end
-  
-  def vertex_from_points ( points )
-  	vertex points[0], points[1], points[2]
-  end
-  
-end
-
-RgbCube.new :title => "Rgb Cube"