HelpSource/Classes/Pspawner.schelp

   1 class:: Pspawner
   2 summary:: dynamic control of multiple event streams from a Routine
   3 related:: Classes/Pspawn
   4 categories:: Streams-Patterns-Events>Patterns>Parallel
   5
   6 description::
   7
   8 Pspawner allows a routine to dynamically start and stop subpatterns.
   9
  10 ClassMethods::
  11
  12 method::new
  13
  14 argument::function
  15 The function defines a link::Classes/Routine:: that receives a link::Classes/Spawner:: as its sole argument. All control of subpatterns is through the spawner.
  16
  17 link::Classes/Spawner:: responds to the messages:
  18
  19 definitionlist::
  20 ## par ||
  21 Begin an event stream in parallel to the routine. If delta is non-zero, the pattern will begin that many beats after 'now', provided that now + delta is later than the next event that the Spawner will generate. The method returns the stream. This may be called from any object.
  22
  23 ## seq ||
  24 Run the entire pattern and then return control to the routine.
  25
  26 ## wait ||
  27 Wait strong::dur:: seconds and then return control to the routine.
  28
  29 ## suspend ||
  30 Find the stream in the Spawner and stop it, returns nil if the stream is not found, the stream otherwise.
  31
  32 ## suspendAll ||
  33 Stop all substreams of the Spawner.
  34 ::
  35
  36 note::
  37 We should move the documentation of above methods to the link::Classes/Spawner:: helpfile...
  38 ::
  39
  40 Examples::
  41
  42 code::
  43 // example 1: a simple Pspawner
  44
  45 (
  46 Pspawner({ | sp |
  47
  48 // parallel in-c'ish pulses will run throughout the example
  49         sp.par(Pbind(*[ degree: [0,7], octave: 7, dur: 0.2, db: Pseq([-20, -24, -22, -24], inf)]) );
  50
  51 // scales in sequence with pauses
  52         sp.seq(
  53                 Pbind(*[ degree: Pseq((0..7).mirror), dur: 0.2])
  54         );
  55         sp.wait(0.4);
  56         sp.seq(
  57                 Ppar([
  58                         Pbind(*[ degree: Pseq((0..7).mirror), dur: 0.2, octave: 4]),
  59                         Pbind(*[ degree: Pseq((0..7).reverse.mirror), dur: 0.2])
  60                 ])
  61
  62         );
  63         sp.wait(3);
  64         sp.seq(
  65                 Pbind(*[ degree: Pseq((0..7).mirror), dur: 0.2, mtranspose: (0,2..14)])
  66         );
  67
  68 // scales overlaped at 0.4 second intervals
  69
  70         10.do {
  71                 sp.par(
  72                         Pbind(*[ degree: Pseq((0..7).mirror), dur: 0.2])
  73                 );
  74
  75                 sp.wait(0.4)
  76         };
  77         sp.wait(1.6);
  78         sp.suspendAll;
  79 }).play
  80 )
  81
  82
  83 (
  84 // example 2: create 5 streams at 4 second intervals
  85 // then delete them in the order they were created
  86
  87 Pspawner({ | sp |
  88         var streams, stream;
  89         // start patterns, collect the resultant event streams
  90         streams = [2, 3, 4, 6, 7, 8].collect { | i |
  91                 stream = sp.par(Pbind(*[
  92                         harmonic: i,
  93                         ctranspose:     [0, 1, 3]/40,
  94                         octave: Pbrown(2,8,2), dur: 1/i, db: -30
  95                 ]) );
  96                 sp.wait(4);
  97                 stream;
  98         };
  99
 100         // now stop those streams one by one
 101         streams.do { | s | sp.suspend(s); sp.wait(4) };
 102 }).play
 103 )
 104
 105 (
 106 // example 3: define a Pspawner and use Pattern manipulations
 107 p = Pspawner({ | sp |
 108
 109         sp.par(Pbind(*[octave: 5, degree: Pbrown( -7, 7, 3), dur: 0.2]) );
 110
 111         sp.wait(2);
 112         sp.par(Pbind(*[octave: 5, degree: Pbrown( -7, 7, 3), dur: 0.1]) );
 113         sp.wait(1);
 114         sp.par(Pbind(*[octave: 6, degree: Pbrown( -7, 7, 3), dur: 0.05]) );
 115         sp.wait(0.5);
 116
 117         sp.wait(4);
 118         sp.par(Pbind(*[octave: 5, degree: Pbrown( -7, 7, 3), dur: 0.2]) );
 119
 120         sp.wait(4);
 121         sp.suspendAll;
 122 });
 123 )
 124
 125 // play the basic patten
 126 ( p.play )
 127
 128 (
 129 // manipulate it with Pchain
 130 Pchain(
 131         Pbind(*[ctranspose: 0 + Pwhite(-0.1, 0.1)]),
 132         Pbind(*[mtranspose: Pkey(\mtranspose) + Pstutter(8, Prand([0,[-3,0,2],[0,2,4,6,8,10]], inf)) ] ),
 133         Pn(Pseq([p, (type:\rest, dur: 0.4)]) ),
 134         Pbind(*[
 135                 db: Pstep(Pseq([-10, -13, -13, -11, -13, -13], inf), 0.1) - 10,
 136                 mtranspose: Pstep(Pwhite(-7, 7), Prand([5,4,2],inf) )
 137         ])
 138  ).play(protoEvent: Event.default)
 139 )
 140
 141 // example 4: altering the contents of the Pspawner from separate code
 142
 143 (
 144 a = Pspawner({ |sp |
 145         c = sp;                         // store the Spawner in a global variable
 146         100.do{ sp.wait(1) }
 147 });
 148 a.play;
 149 )
 150
 151 (                                       // c will not be valid until the Pspawner has run
 152 b = c.par(                              // now start a pattern in spawner
 153         Pbind(*[degree: Pseq((0..6) ++ (7..1), inf), dur: 0.2])
 154 );
 155 )
 156 c.suspend(b)                            // we can suspend and resume the stream
 157 c.par(b)
 158 c.suspend(b)
 159 (
 160 b = c.par(                              // or just start up a new pattern
 161         Pbind(*[degree: Pseq((0..6) ++ (7..1), inf), dur: 0.2])
 162 );
 163 )
 164
 165 // example 5: Spawner can be used directly in the manner of Pspawner.
 166 // This allows external code to access to the spawner whether or not it has run
 167 (
 168 c = Spawner({ |sp |
 169         100.do{ sp.wait(1) }
 170 });
 171 b = c.par(                              // now start a pattern in spawner
 172         Pbind(*[degree: Pseq((0..6) ++ (7..1), inf), dur: 0.2])
 173 );
 174 c.play;                                 // in this case, c is always valid
 175 )
 176 c.suspend(b)                            // we can suspend and resume the stream
 177 c.par(b)
 178 c.suspend(b)
 179 (
 180 b = c.par(                              // or just start up a new pattern
 181         Pbind(*[degree: Pseq((0..6) ++ (7..1), inf), dur: 0.2])
 182 );
 183 )
 184
 185 (
 186 Pspawner({ | sp |
 187         (1..5).do { | i |
 188                 sp.par(Pbind(*[
 189                         octave: i + 2,
 190                         degree: Pwhite(0,7), dur: 1/i, db: -30
 191                 ]) );
 192                 sp.wait(4);
 193         };
 194         sp.suspendAll;
 195 }).play
 196 )
 197 ::