HelpSource/Classes/TDuty.schelp

   1 class:: TDuty
   2 summary:: Demand results as trigger from demand rate UGens.
   3 related:: Classes/Demand, Classes/Duty
   4 categories::  UGens>Demand
   5
   6
   7 Description::
   8
   9 A value is demanded each UGen in the list and output as a trigger
  10 according to a stream of duration values. The unit generators in the list
  11 should be 'demand' rate.
  12
  13
  14 When there is a trigger at the reset input, the demand rate UGens in the
  15 list and the duration are reset. The reset input may also be a demand
  16 UGen, providing a stream of reset times.
  17
  18
  19 classmethods::
  20
  21 method::ar, kr
  22
  23 argument::dur
  24
  25 Time values. Can be a demand UGen or any signal. The next trigger
  26 value is acquired after duration.
  27
  28
  29 argument::reset
  30
  31 Trigger or reset time values. Resets the list of UGens and the
  32 duration UGen when triggered. The reset input may also be a
  33 demand UGen, providing a stream of reset times.
  34
  35
  36 argument::level
  37
  38 Demand UGen providing the output values.
  39
  40
  41 argument::doneAction
  42
  43 A doneAction that is evaluated when the duration stream ends. See
  44
  45 link::Reference/UGen-doneActions::  for more detail.
  46
  47
  48 argument::gapFirst
  49 when 0 (default), the UGen does the first level poll immediately and then waits for the first durational value. When this is 1, the UGen initially polls the first durational value, waits for that duration, and then polls the first level (along with polling the next durational value). So gapFirst > 0 makes TDuty behave like link::Classes/TDuty_old::.
  50
  51 Examples::
  52
  53 code::
  54
  55 // examples
  56
  57 s.boot;
  58
  59
  60 // play a little rhythm
  61
  62 { TDuty.ar(Dseq([0.1, 0.2, 0.4, 0.3], inf)) }.play; // demand ugen as durations
  63
  64
  65
  66 // amplitude changes
  67 (
  68         {
  69                 var trig;
  70                 trig = TDuty.ar(
  71                                 Dseq([0.1, 0.2, 0.4, 0.3], inf), // demand ugen as durations
  72                                 0,
  73                                 Dseq([0.1, 0.4, 0.01, 0.5, 1.0], inf) // demand ugen as amplitude
  74                         );
  75                 Ringz.ar(trig, 1000, 0.1)
  76
  77         }.play;
  78 )
  79
  80 (
  81         {
  82                 var trig;
  83                 trig = TDuty.ar(
  84                                 MouseX.kr(0.001, 2, 1), // control rate ugen as durations
  85                                 0,
  86                                 Dseq([0.1, 0.4, 0.01, 0.5, 1.0], inf)
  87                         );
  88                 Ringz.ar(trig, 1000, 0.1)
  89
  90         }.play;
  91 )
  92
  93
  94
  95
  96 // demand ugen as audio oscillator
  97
  98 (
  99         {
 100                 var a, trig, n=5, m=64;
 101                 a = {
 102                         var x;
 103                         x = { 0.2.rand2 } ! m;
 104                         x = x ++ ({  Drand({ 0.2.rand2 } ! n) } ! m.rand);
 105                         Dseq(x.scramble, inf)
 106                 } ! n;
 107                 trig = TDuty.ar(
 108                                 MouseX.kr(1, 2048, 1) * SampleDur.ir * [1, 1.02],
 109                                 0,
 110                                 Dswitch1(a, MouseY.kr(0, n-1))
 111                         );
 112                 Ringz.ar(trig, 1000, 0.01)
 113
 114         }.play;
 115 )
 116
 117
 118 // single impulses
 119
 120 (
 121 SynthDef("delta_demand", { arg amp=0.5, out;
 122         OffsetOut.ar(out,
 123                 TDuty.ar(Dseq([0]), 0, amp, 2)
 124         )
 125 }).send(s);
 126 )
 127
 128 fork { 10.do { s.sendBundle(0.2, ["/s_new", "delta_demand", -1]); 1.0.rand.wait } };
 129
 130
 131 // chain of impulses
 132 (
 133 SynthDef("delta_demand2", {
 134         OffsetOut.ar(0,
 135                 TDuty.ar(Dgeom(0.05, 0.9, 20), 0, 0.5, 2)
 136         )
 137 }).send(s);
 138 )
 139
 140 fork { 10.do { s.sendBundle(0.2, ["/s_new", "delta_demand2", -1]); 1.0.rand.wait } };
 141
 142
 143
 144 // multichannel expansion
 145
 146 (
 147         {
 148                 var t;
 149                 t = TDuty.ar(
 150                                 Drand([Dgeom(0.1, 0.8, 20), 1, 2], inf) ! 2,
 151                                 0,
 152                                 [Drand({ 1.0.rand } ! 8, inf), Dseq({ 1.0.rand } ! 8, inf)] * 2
 153                         );
 154                 x = Ringz.ar(t, [400, 700], 0.1) * 0.1;
 155
 156         }.play;
 157 )
 158
 159 ::
 160