HelpSource/Classes/Duty.schelp

   1 class:: Duty
   2 summary:: Demand results from demand rate UGens.
   3 related:: Classes/Demand, Classes/TDuty
   4 categories::  UGens>Demand
   5
   6
   7 Description::
   8
   9 A value is demanded each UGen in the list and output according to a
  10 stream of duration values. The unit generators in the list should be
  11 '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 level
  26 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 Examples::
  49 code::
  50 (
  51         {
  52                 var freq;
  53                 freq = Duty.kr(
  54                                 Drand([0.01, 0.2, 0.4], inf), // demand ugen as durations
  55                                 0,
  56                                 Dseq([204, 400, 201, 502, 300, 200], inf)
  57                         );
  58                 SinOsc.ar(freq * [1, 1.01]) * 0.1
  59
  60         }.play;
  61 )
  62
  63 (
  64         {
  65                 var freq;
  66                 freq = Duty.kr(
  67                                 MouseX.kr(0.001, 2, 1), // control rate ugen as durations
  68                                 0,
  69                                 Dseq([204, 400, 201, 502, 300, 200], inf)
  70                         );
  71                 SinOsc.ar(freq * [1, 1.01]) * 0.1
  72
  73         }.play;
  74 )
  75 ::
  76
  77 Resetting the demand ugens:
  78 code::
  79 (
  80         {
  81                 var freq;
  82                 freq = Duty.kr(
  83                                 Dseq([0.2, 0.3, 0.4, Dseq([1, 1, 1, 2, 1, 2], inf)]) / 2,
  84                                 Dust.kr(1), // control rate reset
  85                                 Dseq([0, 1, 2, Dseq([1, 2, 3, 4, 5], inf)])
  86                         ) * 30 + 250;
  87                 SinOsc.ar(freq * [1, 1.01]) * 0.1
  88
  89         }.play;
  90 )
  91
  92 (
  93         {
  94                 var freq;
  95                 freq = Duty.kr(
  96                                 Dseq([0.2, 0.3, 0.4, Dseq([1, 1, 1, 2, 1, 2], inf)]) / 2,
  97                                 Dseq([1, 2, 4, 5], inf), // demand rate reset
  98                                 Dseq([0, 1, 2, Dseq([1, 2, 3, 4, 5], inf)])
  99                         ) * 30 + 250;
 100                 SinOsc.ar(freq * [1, 1.01]) * 0.1
 101
 102         }.play;
 103 )
 104 ::
 105
 106 Demand ugen as audio oscillator:
 107 code::
 108 (
 109         {
 110                 var a, n=5, m=64;
 111                 a = {
 112                         var x;
 113                         x = { 0.2.rand2 } ! m;
 114                         x = x ++ ({  Drand({ 0.2.rand2 } ! n) } ! m.rand);
 115                         Dseq(x.scramble, inf)
 116                 } ! n;
 117                 Duty.ar(
 118                                 MouseX.kr(1, 125, 1) * SampleDur.ir * [1, 1.02],
 119                                 0,
 120                                 Dswitch1(a, MouseY.kr(0, n-1))
 121                         )
 122
 123         }.play;
 124 )
 125 ::
 126
 127 single sample feedback: a lin cong algorithm:
 128 code::
 129 (
 130 b = Buffer.alloc(s, 1);
 131 {
 132 var x, y, rate, a, c, m;
 133         rate = MouseX.kr(100, SampleRate.ir);
 134         a = 1.1;
 135         c = 0.13;
 136         m = 1.0;
 137         x = Dbufrd(b); // read from buffer
 138         x = x * a + c % m;
 139         y = Dbufwr(x, b); // write to buffer
 140         Duty.ar(1 / rate, 0, y) * 0.1;
 141 }.play;
 142 )
 143 ::
 144