HelpSource/Classes/PatternProxy.schelp

   1 class:: PatternProxy
   2 summary:: stream reference
   3 categories:: Libraries>JITLib>Patterns
   4 related:: Classes/Pdefn
   5
   6 description::
   7 Keeps a reference to a stream that can be replaced while playing. Multiple streams are thus handled without creating dependancies.
   8
   9 ClassMethods::
  10
  11 method::new
  12 create a new instance with a pattern (the source). the pattern should be a emphasis::value pattern:: (see link::Classes/Pdefn::).
  13
  14 for event pattern proxy, see: link::Classes/EventPatternProxy::. instead of a pattern, a strong::function:: can be passed in, creating a routine.
  15
  16 method::default
  17 a default source, if none is given. the default is 1.0 (it is not 0.0 in order to make it safe for durations)
  18
  19 method::defaultQuant
  20 set the default quantization value for the class. (default: nil)
  21
  22 InstanceMethods::
  23
  24 method::source
  25 set the source. If a quantization is given, schedule this change to the next beat
  26
  27 method::clear
  28 set the source to nil
  29
  30 method::quant
  31 set or get the quantization value
  32
  33 method::condition
  34 provide a condition under which the pattern is switched when a new one is inserted. the stream value and a count is passed into the function. the methods strong::count_(n):: simply counts up to n and switches the pattern then
  35
  36 method::embedInStream
  37 just like any pattern, embeds itself in stream
  38
  39 subsection::extra methods
  40
  41 PatternProxy implements some methods for the benefits of its subclasses link::Classes/Pdefn:: / link::Classes/Pdef:: / link::Classes/Tdef:: which are not useful for link::Classes/PatternProxy:: and link::Classes/TaskProxy::.
  42
  43 method::envir
  44 provide a default environment for the proxy. If given, it is used as an environment for the routine function. When set for the first time, the routine pattern is rebuilt.
  45
  46 method::set
  47 set arguments in the environment. If there is none, it is created and the pattern is rebuilt.
  48
  49 method::endless
  50 returns a Proutine that plays the proxy endlessly, replacing strong::nil:: with a strong::default:: value (1). This allows to create streams that idle on until a new pattern is inserted.
  51
  52 Examples::
  53
  54 code::
  55 a = PatternProxy(Pseq([1, 2, 3], inf));
  56
  57 x = Pseq([0, 0, a], inf).asStream;
  58
  59 t = Task({ loop({ x.next.postln; 0.3.wait }) }).play;
  60
  61
  62 a.source = Pseq([55, 66, 77], inf);
  63 a.source = Pseq([55, 66, 77], 1);
  64
  65 t.stop;
  66 ::
  67
  68 code::
  69 // PatternProxy, like Pdefn can be accessed in multiple streams
  70
  71 (
  72 SynthDef("Pdefhelp", { arg out, freq, sustain=1, amp=1, pan;
  73         var env, u=1;
  74         env = EnvGen.kr(Env.perc(0.03, sustain), 1, doneAction:2);
  75         5.do { var d; d = exprand(0.01, 1); u = SinOsc.ar(d * 300, u, rrand(0.1,1.2) * d, 1) };
  76         Out.ar(out, Pan2.ar(SinOsc.ar(u + 1 * freq, 0, amp * env), pan));
  77
  78 }).add;
  79 s.boot;
  80 )
  81
  82 (
  83 x = PatternProxy.new;
  84 x.source = Pseq([0, 3, 2], inf);
  85
  86 Pset(\instrument, \Pdefhelp,
  87         Ppar([
  88         Pbind(\degree, x),
  89         Pbind(\degree, x, \dur, 1/3)
  90 ])
  91 ).play;
  92 )
  93
  94 x.source = Prand([0, 3, [1s, 4]], inf);
  95
  96 x.source = Pn(Pshuf([0, 3, 2, 7, 6], 2), inf);
  97
  98
  99
 100 // if quant is set, the update is done at the next beat or whatever is specified:
 101
 102 x.quant = 4;
 103 x.source = Pn(Pseries(0, 1, 8), inf);
 104
 105 x.quant = nil; // reactivate immediacy
 106
 107 (
 108 x.source = Prout {
 109         loop {
 110         4.do { |i|
 111                 #[2, 3, 4].choose.yield;
 112                 #[5, 0, 11].choose.yield;
 113                 #[6, 3, 4].choose.do { |j| (i % j).yield };
 114         }
 115         }
 116 }
 117 )
 118 ::