ruck 0.1.0 → 0.1.2

data/README

@@ -41,7 +41,6 @@ UGenShreduler:
     [sin >> wav, sin2] >> blackhole
     play 3.seconds
 
-
 RealTimeShreduler
 
   This shreduler attempts to keep virtual time in line with
@@ -54,32 +53,28 @@ MIDIShreduler
   MIDI playback and saving MIDI to disk. An example runner
   is provided in midi_runner.rb which you invoke like this:
   
-    $ ruby midilib_runner.rb MIDI_FILENAME NUM_TRACKS LIVE SCRIPT_FILENAME [...]
+    $ ruck_midi MIDI_FILENAME NUM_TRACKS LIVE SCRIPT_FILENAME [...]
   
   where LIVE is "no" to only save the MIDI output, or "yes"
   to also play in real-time.
 
+GLAppShreduler
+
+  You don't want to know. (But the scripts are included so
+  you can find them if you're really curious.)
+
 USAGE
 =====
 
-ugen_runner.rb is an (example) program that lets you run scripts
-as you do with ChucK, with a shreduler that pulls samples from
-the unit generator graph (through the blackhole):
+This project has tons of examples because even though the library
+is tiny, there's a lot to test, and a lot of ways to use it.
 
-  $ ruby ugen_runner.rb examples/ex01.rb
+For examples of how to implement your own Shreduler, see the bottom
+of lib/ruck/shreduling.rb and all the scripts in bin/.
 
-It uses a UGenShreduler with a hard-coded sample rate. You can use it
-as an example for how to embed your own shreduler. It boils down
-to this:
+For example of how to use the provided Shredulers, check the
+examples/ directory. Those scripts contain no boilerplate includes
+because they are written to be invoked on the command line by
+one of the bin/ scripts. For example:
 
-  require "ruck"
-  
-  @shreduler = Ruck::Shreduler.new # replace with your subclass
-  
-  # repeat this part as necessary to seed @shreduler with shreds
-  @shreduler.spork("main") do
-    ...
-  end
-  
-  # this returns when no shreds remain
-  @shreduler.run
+  $ ruck_ugen examples/ex01.rb

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.2

data/bin/ruck_glapp

@@ -4,6 +4,8 @@ $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 # requires glapp gem
 # sudo gem install alltom-glapp
 # see http://alltom.com/pages/glapp for more details
+# UPDATE: ugh, github stopped producing gems.
+#         find a way to get it on your own 'til I fix that.
 
 require "ruck"
 
@@ -12,32 +14,52 @@ require "glapp"
 
 class GLAppShreduler < Ruck::Shreduler
   def initialize
-    @shreds_waiting_for_next_frame = []
+    @shred_queues = {}
+    [:frame,
+     :key_down, :key_up,
+     :mouse_down, :mouse_up, :mouse_move].each do |q|
+      @shred_queues[q] = []
+    end
     super
   end
   
+  def starting
+    @start_time = Time.now
+  end
+  
   def actual_now
     Time.now - @start_time
   end
   
-  def enqueue_for_next_frame(shred)
-    @shreds_waiting_for_next_frame << shred
+  def sleep_current_til(queue)
+    shred = current_shred
     @shreds.delete(shred)
+    @shred_queues[queue] << shred
+    shred.yield(0)
+    
+    @ev
   end
   
-  def next_frame_has_arrived
-    @shreds += @shreds_waiting_for_next_frame
+  def raise_event(ev, queue)
+    # should use actual_now,
+    # but we don't want to put it into the future
+    new_now = actual_now
+    new_now = [new_now, next_shred.now].min if next_shred
+    @now = new_now
     
-    @shreds_waiting_for_next_frame.each do |shred|
-      shred.now = now
-    end
+    @ev = ev # returned by sleep_current_til
+    
+    shreds = @shred_queues[queue]
+    @shred_queues[queue] = []
     
-    @shreds_waiting_for_next_frame = []
+    shreds.each do |shred|
+      shred.now = new_now
+      @shreds << shred
+      invoke_shred shred
+    end
   end
   
   def catch_up
-    @start_time ||= Time.now
-    
     while shreds.length > 0 && next_shred.now < actual_now
       run_one
     end
@@ -45,33 +67,96 @@ class GLAppShreduler < Ruck::Shreduler
 end
 
 module ShredLocal
-  def wait_for_frame
-    SHREDULER.enqueue_for_next_frame(SHREDULER.current_shred)
-    SHREDULER.current_shred.yield(0)
+  def spork(name = "unnamed", &shred)
+    SHREDULER.spork(name, &shred)
   end
   
   def wait(seconds)
     SHREDULER.current_shred.yield(seconds)
   end
+  
+  def wait_for_frame
+    SHREDULER.sleep_current_til(:frame)
+  end
+  
+  def wait_for_key_down
+    SHREDULER.sleep_current_til(:key_down)
+  end
+  
+  def wait_for_key_up
+    SHREDULER.sleep_current_til(:key_down)
+  end
+  
+  def wait_for_mouse_down
+    SHREDULER.sleep_current_til(:mouse_down)
+  end
+  
+  def wait_for_mouse_up
+    SHREDULER.sleep_current_til(:mouse_up)
+  end
+  
+  def wait_for_mouse_move
+    SHREDULER.sleep_current_til(:mouse_move)
+  end
 end
 
 class MySketch
+  include GLApp
+  
   def setup
     ARGV.each do |filename|
       SHREDULER.spork(filename) do
         require filename
       end
     end
+    @events = []
+    
+    SHREDULER.starting
   end
   
   def draw
-    SHREDULER.catch_up
-    SHREDULER.next_frame_has_arrived
+    @events.each do |pair|
+      ev, queue = pair
+      SHREDULER.raise_event ev, queue
+    end
+    @events = []
+    
+    SHREDULER.catch_up # execute shreds whose time came while drawing previous frame
+    
+    SHREDULER.raise_event Object.new, :frame
+  end
+  
+  def keyboard_down(key, modifiers)
+    @events << [Struct.new(:key).new(key), :key_down]
+  end
+  
+  def keyboard_up(key, modifiers)
+    @events << [Struct.new(:key).new(key), :key_up]
+  end
+  
+  def special_keyboard_down(key, modifiers)
+    @events << [Struct.new(:key).new(key), :key_down]
+  end
+  
+  def special_keyboard_up(key, modifiers)
+    @events << [Struct.new(:key).new(key), :key_up]
+  end
+  
+  def mouse_click(button, state, x, y)
+    if state == 0
+      @events << [Struct.new(:button, :x, :y).new(button, x, y), :mouse_down]
+    else
+      @events << [Struct.new(:button, :x, :y).new(button, x, y), :mouse_up]
+    end
+  end
+  
+  def mouse_motion(x, y)
+    @events << [Struct.new(:x, :y).new(x, y), :mouse_move]
   end
 end
 
-include GLApp
-include ShredLocal
 SHREDULER = GLAppShreduler.new
 
+include GLApp::Helpers
+include ShredLocal
 MySketch.new.show 800, 600, "My Sketch"

data/bin/ruck_midi

@@ -124,6 +124,12 @@ module ShredLocal
 
 end
 
+def save
+  return if @saved
+  @saved = true
+  File.open(MIDI_FILENAME, "wb") { |file| SEQUENCE.write(file) }
+end
+
 FILENAMES.each do |filename|
   unless File.readable?(filename)
     LOG.fatal "Cannot read file #{filename}"
@@ -138,6 +144,8 @@ FILENAMES.each do |filename|
   end
 end
 
+at_exit { save }
+
 SHREDULER.run
 
-File.open(MIDI_FILENAME, "wb") { |file| SEQUENCE.write(file) }
+save

data/bin/ruck_sleep

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require "ruck"
+
+# stuff accessible in a shred
+module ShredLocal
+  
+  def now
+    SHREDULER.now
+  end
+
+  def spork(name = "unnamed", &shred)
+    SHREDULER.spork(name, &shred)
+  end
+
+  def wait(seconds)
+    SHREDULER.current_shred.yield(seconds)
+  end
+
+  def finish
+    shred = SHREDULER.current_shred
+    SHREDULER.remove_shred shred
+    shred.finish
+  end
+
+end
+
+
+SAMPLE_RATE = 1
+SHREDULER = Ruck::RealTimeShreduler.new
+
+filenames = ARGV
+filenames.each do |filename|
+  unless File.readable?(filename)
+    LOG.fatal "Cannot read file #{filename}"
+    exit
+  end
+end
+
+filenames.each do |filename|
+  SHREDULER.spork(filename) do
+    include ShredLocal
+    require filename
+  end
+end
+SHREDULER.run

data/examples/glapp/ex01.rb

@@ -1,9 +1,24 @@
 
 clear
 
+spork("framerate watcher") do
+  start_time = Time.now
+  frames = 0
+  
+  loop do
+    wait_for_frame
+    frames += 1
+    if frames % 100 == 0
+      puts "#{frames.to_f / (Time.now - start_time)}"
+    end
+  end
+  
+end
+
 loop do
   wait 2
   
+  glColor 1, 0, 0
   glTranslate(0, 0, -5)
   glutSolidCube(2)
   

data/examples/glapp/ex02.rb

@@ -0,0 +1,57 @@
+
+require "rubygems"
+require "midiator"
+
+$midi = MIDIator::Interface.new
+$midi.use :dls_synth
+$midi.instruct_user!
+
+def note_on(note, velocity = 127, channel = 0)
+  $midi.driver.note_on(note, channel, velocity)
+end
+
+def note_off(note, channel = 0)
+  $midi.driver.note_on(note, channel, 0)
+end
+
+def star_shifter(key)
+  wait 3
+  @stars.shift
+  note_off(key)
+end
+
+spork do
+  while ev = wait_for_key_down
+    note_on(ev.key)
+
+    @stars << Star.new
+    spork { star_shifter ev.key }
+  end
+end
+
+spork do
+  while ev = wait_for_key_up
+  end
+end
+
+class Star
+  def initialize
+    @x = rand * 2 - 1
+    @y = rand * 2 - 1
+  end
+  
+  def draw
+    glPushMatrix
+      glTranslate @x, @y, -5
+      glutSolidCube(0.1)
+    glPopMatrix
+  end
+end
+
+clear
+
+@stars = []
+while wait_for_frame
+  clear
+  @stars.each { |star| star.draw }
+end

data/examples/glapp/ex03.rb

@@ -0,0 +1,9 @@
+
+spork do
+  loop do
+    ev = wait_for_key_down
+    puts "you pressed #{ev.key}"
+  end
+end
+
+clear

data/examples/midi/ex02.rb

@@ -0,0 +1,72 @@
+
+def maybe
+  rand >= 0.5
+end
+
+@base = 43
+@scale = 0
+@chord = 0
+
+major_scale = [0, 2, 4, 5, 7, 9, 11]
+minor_scale = [0, 2, 3, 5, 7, 8, 11]
+@scales = [major_scale, minor_scale]
+
+def scale(note, scale)
+  len = scale.length
+  oct = note / len
+  off = note % len
+  while off < 0
+    off += len
+    oct -= 1
+  end
+  oct * 12 + scale[off]
+end
+
+def play(note, dur = 1.beat)
+  midi_note = @base + scale(note, @scales[@scale])
+  note_on midi_note, 100
+  wait dur
+  note_off midi_note
+end
+
+def change_chords
+  loop do
+    wait 4.beats
+    @chord = rand(7)
+    if rand <= 0.1
+      @scale = (@scale + 1) % @scales.length
+    end
+  end
+end
+
+def play_chord(dur)
+  spork { play(@chord, dur) }
+  spork { play(@chord + 2, dur) }
+  spork { play(@chord + 4, dur) }
+end
+
+def play_chords
+  loop do
+    if maybe && maybe
+      play_chord 2.beats
+      wait 2.beats
+      play_chord 2.beats
+      wait 2.beats
+    else
+      play_chord 4.beats
+      wait 4.beats
+    end
+  end
+end
+
+def play_melody
+  loop do
+    len = ((rand(2) + 1) / 2.0).beats
+    play(@chord + 7 + 2 * rand(4), len)
+    wait len
+  end
+end
+
+spork { change_chords }
+spork { play_chords }
+spork { play_melody }

data/examples/ugen/ex10.rb

@@ -2,14 +2,14 @@
 
 spork("a") do
   loop do
-    play 1.second
+    wait 1
     puts "second"
   end
 end
 
 spork("b") do
   loop do
-    play 0.5.second
+    wait 0.5
     puts "       half-second"
   end
 end

data/lib/ruck/shreduling.rb

@@ -2,7 +2,7 @@
 module Ruck
 
   class Shred
-    attr_reader :now
+    attr_accessor :now
     attr_accessor :finished
 
     def initialize(shreduler, now, name, &block)
@@ -15,17 +15,23 @@ module Ruck
 
     def go(resume)
       @resume = resume
+      
+      # TODO
+      # I don't think this is the right place to catch errors.
+      # I've read the strangest memory errors after an exception
+      # is caught here; I have a feeling exceptions ought to be
+      # caught within the continuation itself.
       begin
         @block.call self
       rescue => e
         LOG.error "#{self} exited uncleanly:\n#{e}\n#{e.backtrace}"
       end
+      
       @finished = true
     end
 
     def yield(samples)
       LOG.debug "shred #{self} yielding #{samples}"
-      samples = samples
       @now += samples
       callcc do |cont|
         @block = cont # save where we are
@@ -81,20 +87,25 @@ module Ruck
       @now = new_now
     end
     
-    # invokes the next shred, simulates to the new VM time, then returns
-    def run_one
-      @current_shred = next_shred
-      
-      sim_to(@current_shred.now)
-      
+    def invoke_shred(shred)
       # execute shred, saving this as the resume point
       LOG.debug "resuming shred #{@current_shred} at #{now}"
+      @current_shred = shred
       callcc { |cont| @current_shred.go(cont) }
       LOG.debug "back to run loop"
+    end
+    
+    # invokes the next shred, simulates to the new VM time, then returns
+    def run_one
+      shred = next_shred
+      
+      sim_to(shred.now)
+      
+      invoke_shred shred
 
       if @current_shred.finished
-        LOG.debug "#{@current_shred} finished"
-        @shreds.delete(@current_shred)
+        LOG.debug "#{shred} finished"
+        @shreds.delete(shred)
       end
     end
 

data/ruck.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ruck}
-  s.version = "0.1.0"
+  s.version = "0.1.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Tom Lieber"]
-  s.date = %q{2009-11-16}
+  s.date = %q{2009-11-21}
   s.description = %q{      Ruck uses continuations and a simple scheduler to ensure "shreds"
       (threads in Ruck) are woken at precisely the right time according
       to its virtual clock. Schedulers can map virtual time to samples
@@ -20,7 +20,7 @@ Gem::Specification.new do |s|
       are provided. See the README or the web page for details.
 }
   s.email = %q{tom@alltom.com}
-  s.executables = ["ruck_glapp", "ruck_midi", "ruck_ugen"]
+  s.executables = ["ruck_glapp", "ruck_midi", "ruck_sleep", "ruck_ugen"]
   s.extra_rdoc_files = [
     "README"
   ]
@@ -31,9 +31,13 @@ Gem::Specification.new do |s|
      "VERSION",
      "bin/ruck_glapp",
      "bin/ruck_midi",
+     "bin/ruck_sleep",
      "bin/ruck_ugen",
      "examples/glapp/ex01.rb",
+     "examples/glapp/ex02.rb",
+     "examples/glapp/ex03.rb",
      "examples/midi/ex01.rb",
+     "examples/midi/ex02.rb",
      "examples/ugen/ex01.rb",
      "examples/ugen/ex02.rb",
      "examples/ugen/ex03.rb",
@@ -66,7 +70,10 @@ Gem::Specification.new do |s|
   s.summary = %q{strong timing for Ruby: cooperative threads on a virtual clock}
   s.test_files = [
     "examples/glapp/ex01.rb",
+     "examples/glapp/ex02.rb",
+     "examples/glapp/ex03.rb",
      "examples/midi/ex01.rb",
+     "examples/midi/ex02.rb",
      "examples/ugen/ex01.rb",
      "examples/ugen/ex02.rb",
      "examples/ugen/ex03.rb",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruck
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors: 
 - Tom Lieber
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-16 00:00:00 -08:00
+date: 2009-11-21 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -18,6 +18,7 @@ email: tom@alltom.com
 executables: 
 - ruck_glapp
 - ruck_midi
+- ruck_sleep
 - ruck_ugen
 extensions: []
 
@@ -30,9 +31,13 @@ files:
 - VERSION
 - bin/ruck_glapp
 - bin/ruck_midi
+- bin/ruck_sleep
 - bin/ruck_ugen
 - examples/glapp/ex01.rb
+- examples/glapp/ex02.rb
+- examples/glapp/ex03.rb
 - examples/midi/ex01.rb
+- examples/midi/ex02.rb
 - examples/ugen/ex01.rb
 - examples/ugen/ex02.rb
 - examples/ugen/ex03.rb
@@ -87,7 +92,10 @@ specification_version: 3
 summary: "strong timing for Ruby: cooperative threads on a virtual clock"
 test_files: 
 - examples/glapp/ex01.rb
+- examples/glapp/ex02.rb
+- examples/glapp/ex03.rb
 - examples/midi/ex01.rb
+- examples/midi/ex02.rb
 - examples/ugen/ex01.rb
 - examples/ugen/ex02.rb
 - examples/ugen/ex03.rb