HelpSource/Classes/DemandEnvGen.schelp

   1 class:: DemandEnvGen
   2 summary:: Demand rate envelope generator
   3 related:: Classes/Demand, Classes/Duty, Classes/TDuty
   4 categories::  UGens>Demand, UGens>Envelopes
   5
   6 Description::
   7 Plays back break point envelope contours (levels, times, shapes) given by demand ugens. The next values are called when the next node is reached.
   8
   9 classmethods::
  10 private:: categories
  11
  12 method::ar, kr
  13
  14 argument::level
  15
  16 A demand UGen or any other UGen returning level values. If this ends, the
  17
  18 code::doneAction::  is evaluated.
  19
  20
  21 argument::dur
  22
  23 A demand UGen or any other UGen returning time values. If this ends, the
  24
  25 code::doneAction::  is evaluated.
  26
  27
  28 argument::shape
  29
  30 A demand UGen or any other UGen: the number given is the shape
  31 number according to link::Classes/Env::.
  32
  33
  34 argument::curve
  35
  36 A demand UGen or any other UGen returning curve values. if shape is 5, this is the
  37 curve factor.
  38
  39 The possible values are:
  40 table::
  41 ## 0 || flat segments
  42 ## 1 || linear segments, the default
  43 ## 2 || natural exponential growth and decay. In this case, the levels must all be nonzero and the have the same sign.
  44 ## 3 || sinusoidal S shaped segments.
  45 ## 4 || sinusoidal segments shaped like the sides of a Welch window.
  46 ## a Float || a curvature value for all segments.
  47 ## An Array of Floats || curvature values for each segments.
  48 ::
  49
  50 argument::gate
  51
  52 If gate is x ≥ 1, the UGen runs.
  53
  54
  55 If gate is 0 > x > 1, the UGen is released at the next
  56 level (doneAction).
  57
  58
  59 If gate is x < 0, the UGen is sampled and held.
  60
  61
  62 argument::reset
  63
  64 If reset crosses from non-positive to positive, the UGen is reset
  65 at the next level. If it is > 1, it is reset immediately.
  66
  67
  68 argument::levelScale
  69
  70 demand ugen returning level scaling values
  71
  72
  73 argument::levelBias
  74
  75 demand ugen returning level offset values
  76
  77
  78 argument::timeScale
  79
  80 demand ugen returning time scaling values
  81
  82
  83 argument::doneAction
  84
  85 A doneAction that is evaluated when level or duration stream
  86 ends. See link::Reference/UGen-doneActions::  for more detail.
  87
  88
  89 Examples::
  90
  91 code::
  92 // frequency envelope with random times
  93 (
  94         {
  95                 var freq;
  96                 freq = DemandEnvGen.ar(
  97                                 Dseq([204, 400, 201, 502, 300, 200], inf),
  98                                 Drand([1.01, 0.2, 0.1, 2], inf) * MouseY.kr(0.01, 3, 1),
  99                                 7 // cubic interpolation
 100                         );
 101                 SinOsc.ar(freq * [1, 1.01]) * 0.1
 102
 103         }.play;
 104 )
 105
 106 // frequency modulation
 107 (
 108         {
 109                 var freq, list;
 110                 list = { exprand(200, 1000.0) } ! 32;
 111                 freq = DemandEnvGen.ar(
 112                                 { Dseq(list.scramble, inf) } ! 2,
 113                                 SampleDur.ir * MouseY.kr(1, 3000, 1),
 114                                 5, // curve interpoaltion
 115                                 MouseX.kr(-0.01, -4) // curve must be negative for fast interpol.
 116                         );
 117                 SinOsc.ar(freq) * 0.1
 118
 119         }.play;
 120 )
 121
 122
 123 //  gate
 124 // mouse x on right side of screen toggles gate
 125 (
 126         {
 127                 var freq;
 128                 freq = DemandEnvGen.kr(
 129                                 Dwhite(300, 1000, inf).round(100),
 130                                 0.1,
 131                                 5, 0.3, // curve: 0.3
 132                                 MouseX.kr > 0.5,
 133                                 1
 134                         );
 135                 SinOsc.ar(freq * [1, 1.21]) * 0.1
 136
 137         }.play;
 138 )
 139
 140 // sample and hold (0.5 > gate > 0)
 141 // mouse x on right side of screen toggles gate
 142 // mouse y scales frequency
 143 (
 144         {
 145                 var freq;
 146                 freq = DemandEnvGen.kr(
 147                                 Dwhite(300, 1000, inf).round(100),
 148                                 0.1,
 149                                 5, 0.3,
 150                                 MouseX.kr > 0.5 + 0.1
 151                         );
 152                 SinOsc.ar(freq * [1, 1.21]) * 0.1
 153
 154         }.play;
 155 )
 156
 157 // gate
 158 // mouse x on right side of screen toggles gate
 159 // mouse button does soft reset
 160 (
 161         {
 162                 var freq;
 163                 freq = DemandEnvGen.kr(
 164                                 Dseq([Dseries(400, 200, 5), 500, 800, 530, 4000, 900], 2),
 165                                 Dseq([0.2, 0.1, 0.2, 0.3, 0.1], inf),
 166                                 Dseq([1, 0, 0, 6, 1, 1, 0, 2], inf), // shapes
 167                                 0,
 168                                 MouseX.kr > 0.5, // gate
 169                                 MouseButton.kr > 0.5, // reset
 170                                 doneAction:0
 171                         );
 172                 SinOsc.ar(freq * [1, 1.001]) * 0.1
 173
 174         }.play;
 175 )
 176
 177
 178 //  gate
 179 // mouse x on right side of screen toggles sample and hold
 180 // mouse button does hard reset
 181 (
 182         {
 183                 var freq;
 184                 freq = DemandEnvGen.kr(
 185                                 Dseq([Dseries(400, 200, 5), 500, 800, 530, 4000, 900], 2),
 186                                 0.1,
 187                                 3, 0,
 188                                 MouseX.kr > 0.5 - 0.1, // gate: sample and hold
 189                                 MouseButton.kr > 0.5 * 2, // hard reset
 190                                 doneAction: 0
 191                         );
 192                 SinOsc.ar(freq * [1, 1.001]) * 0.1
 193
 194         }.play;
 195 )
 196
 197
 198
 199
 200
 201 // short sequence with doneAction, linear
 202 (
 203         {
 204                 var freq;
 205                 freq = DemandEnvGen.kr(
 206                                 Dseq([1300, 500, 800, 300, 400], 1),
 207                                 0.2,
 208                                 1,
 209                                 doneAction:2
 210                         );
 211                 SinOsc.ar(freq * [1, 1.01]) * 0.1
 212
 213         }.play;
 214 )
 215
 216 // short sequence with doneAction, step
 217 (
 218         {
 219                 var freq;
 220                 freq = DemandEnvGen.kr(
 221                                 Dseq([1300, 500, 800, 300, 400], 1),
 222                                 0.2,
 223                                 0,
 224                                 doneAction:2
 225                         );
 226                 SinOsc.ar(freq * [1, 1.01]) * 0.1
 227
 228         }.play;
 229 )
 230
 231
 232
 233 // a linear ramp
 234 (
 235         {
 236                 var freq;
 237                 freq = DemandEnvGen.kr(
 238                                 Dseq([300, 800], 1),
 239                                 1,
 240                                 1
 241                         );
 242                 SinOsc.ar(freq * [1, 1.01]) * 0.1
 243
 244         }.play;
 245 )
 246
 247
 248
 249 // random gate:  release. gate low level > 0.
 250 // only end points are kept as release levels
 251 (
 252         {
 253                 var freq;
 254                 freq = DemandEnvGen.kr(
 255                                 Dseq([500, 800], inf),
 256                                 0.03,
 257                                 1,0, // linear
 258                                 ToggleFF.kr(Dust.kr(5)) + 0.1 // gate
 259
 260
 261                         );
 262                 SinOsc.ar(freq * [1, 1.01]) * 0.1
 263
 264         }.play;
 265 )
 266
 267 // random gate: sample and hold. gate low level = 0.
 268 (
 269         {
 270                 var freq;
 271                 freq = DemandEnvGen.kr(
 272                                 Dseq([500, 800, 600], inf),
 273                                 0.03,
 274                                 1,0, // linear
 275                                 ToggleFF.kr(Dust.kr(5)), // gate
 276                                 0 // reset
 277
 278                         );
 279                 SinOsc.ar(freq * [1, 1.01]) * 0.1
 280
 281         }.play;
 282 )
 283
 284
 285
 286
 287 // lfnoise1
 288 (
 289         {
 290                         DemandEnvGen.ar(
 291                                 Dwhite(-0.1, 0.1, inf),
 292                                 SampleDur.ir * MouseY.kr(0.5, 20),
 293                                 5,
 294                                 -4
 295                         );
 296
 297
 298         }.play;
 299 )
 300
 301 // lfbrownnoise
 302 (
 303         {
 304                         DemandEnvGen.ar(
 305                                 Dbrown(-0.1, 0.1, 0.1, inf),
 306                                 SampleDur.ir * MouseY.kr(1, 100, 1)
 307                         );
 308
 309
 310         }.play;
 311 )
 312
 313
 314
 315
 316
 317
 318 Server.internal.boot;
 319
 320 // hardsyncing a saw
 321 (
 322         {
 323
 324                         DemandEnvGen.ar(
 325                                 Dseq([Dseries(-0.1, 0.01, 20)], inf),
 326                                 SampleDur.ir * MouseY.kr(1, 100, 1),
 327                                 1, 0,
 328                                 K2A.ar(1),
 329                                 Impulse.ar(MouseX.kr(1, SampleRate.ir * MouseX.kr(0.002, 1, 1), 1), 0, 1.5)
 330
 331                         )
 332
 333
 334         }.scope;
 335 )
 336
 337
 338 // softsyncing a saw
 339 (
 340         {
 341
 342                         DemandEnvGen.ar(
 343                                 Dseq([Dseries(-0.1, 0.01, 20)], inf),
 344                                 SampleDur.ir * MouseY.kr(1, 100, 1),
 345                                 1, 0,
 346                                 K2A.ar(1),
 347                                 Impulse.ar(MouseX.kr(1, SampleRate.ir * MouseX.kr(0.002, 1, 1), 1)) + [0, 0.3]
 348
 349                         )
 350
 351
 352         }.scope;
 353 )
 354
 355
 356
 357 // hardsyncing a saw, som random elements
 358 (
 359         {
 360
 361                         DemandEnvGen.ar(
 362                                 Dseq([Dseries(-0.1, 0.01, 20), Dseries(-0.1, 0.01, 20), Dwhite(-0.1, 0.1, 5)], inf),
 363                                 SampleDur.ir * MouseY.kr(1, 100, 1),
 364                                 3, 0,
 365                                 1,
 366                                 Impulse.ar(MouseX.kr(1, SampleRate.ir * MouseX.kr(0.002, 1, 1), 1), 0, 1.5)
 367
 368                         )
 369
 370
 371         }.scope;
 372 )
 373
 374 // softsyncing a saw, som random elements
 375 (
 376         {
 377
 378                         DemandEnvGen.ar(
 379                                 Dseq([Dseries(-0.1, 0.01, 20), Dseries(-0.1, 0.01, 20), Dwhite(-0.1, 0.1, 5)], inf),
 380                                 SampleDur.ir * MouseY.kr(1, 100, 1),
 381                                 1, 0, // linear interpolation
 382                                 1,
 383                                 Impulse.ar(MouseX.kr(1, SampleRate.ir * MouseX.kr(0.002, 1, 1), 1))
 384
 385                         )
 386
 387
 388         }.scope;
 389 )
 390
 391
 392 // multichannel expansion
 393 // mouse x on right side of screen toggles gate
 394 // mouse y controls speed
 395
 396 (
 397         {
 398                 var freq;
 399                 freq = DemandEnvGen.kr(
 400                                 { Dseq([300, 800, Drand([1000, 460, 300], 1), 400], inf) + 3.0.rand } ! 2,
 401                                 MouseY.kr(0.001, 2, 1),
 402                                 5, -4,
 403                                 MouseX.kr > 0.5
 404                         );
 405                 SinOsc.ar(freq) * 0.1
 406
 407         }.play;
 408 )
 409 ::
 410