SCClassLibrary/Common/Audio/InterplEnv.sc

   1
   2 // InterplEnvs are a fixed duration
   3 // Envelope specification for an IEnvGen, InterplEnv is not a UGen itself
   4
   5 InterplEnv : AbstractEnv {
   6         var <>offset;
   7
   8         *new { arg levels=#[0,1,0], times=#[1,1], curve='lin', offset = 0.0;
   9                 ^super.newCopyArgs(levels, times, curve).offset_(offset)
  10         }
  11
  12         at { arg time;
  13                 var env;
  14                 env = this.asEnv;
  15                 ^env.asArray.envAt((time - offset).max(0))
  16         }
  17
  18         asEnv {
  19                 ^Env(this.levels, this.times, this.curves);
  20         }
  21
  22         storeArgs { ^[levels, times, curves, offset] }
  23
  24         plot { arg size = 400, bounds, minval, maxval, parent;
  25                 this.asEnv.plot(size, bounds, minval, maxval, parent);
  26         }
  27
  28         prAsArray {
  29                 var contents, curvesArray;
  30                 contents = [offset, levels.at(0), times.size, times.sum];
  31                 curvesArray = curves.asArray;
  32                 times.size.do({ arg i;
  33                         contents = contents ++ [
  34                                 times[i],
  35                                 this.class.shapeNumber(curvesArray.wrapAt(i)),
  36                                 this.curveValue(curvesArray.wrapAt(i)),
  37                                 levels[i+1]
  38                         ];
  39                 });
  40                 ^contents
  41         }
  42
  43 }
  44
  45 // InterplXYC([0, 0, \lin], [1, 2, \sin], [2, 0])
  46 // at time 0, value 0, lin to time 1, value 2, sin to time 2, value 0
  47
  48 InterplXYC : InterplEnv {
  49
  50         *new { arg ... xyc;
  51                 var x, y, c, times, levels, curves, offset;
  52                 #x, y, c = xyc.flat.clump(3).flop;
  53                 offset = x[0];
  54                 levels = y;
  55                 times = Array.fill(x.size - 1, { arg i; x[i + 1] - x[i]});
  56                 c.removeAt(c.size - 1);
  57                 ^InterplEnv.new(levels, times, c, offset);
  58         }
  59 }
  60
  61 InterplPairs : InterplEnv {
  62
  63         *new { arg pairs, curve;
  64                 var x, y, times, levels, offset;
  65                 curve = curve ? \lin;
  66                 #x, y = pairs.flat.clump(2).flop;
  67                 offset = x[0];
  68                 levels = y;
  69                 times = Array.fill(x.size - 1, {arg i; x[i + 1] - x[i]});
  70                 ^InterplEnv.new(levels, times, curve, offset);
  71         }
  72 }
  73
  74 // pairs is an array of [time, [val, val, val], time, [val, val, val]]
  75 // format. All chords MUST have the same number of members
  76
  77 InterplChord {
  78         var <envs, <times;
  79
  80         *new { arg pairs;
  81                 ^super.new.init(pairs);
  82         }
  83
  84         init { arg pairs;
  85                 var points;
  86                 times = Array.newClear(pairs.size * 0.5 - 1);
  87                 points = Array.fill(pairs.size * 0.5, {arg i; pairs[i * 2]});
  88                 points.doAdjacentPairs({ arg val1, val2, i; times[i] = val2 - val1 });
  89                 envs = Array.fill(pairs[1].size, {arg i;
  90                         var levels;
  91                         levels = Array.fill(pairs.size * 0.5, {arg j;
  92                                 pairs[j*2+1][i]});
  93                         Env(levels, times)
  94                         })
  95         }
  96
  97         at { arg time;
  98                 ^Array.fill(envs.size, { arg i; envs[i][time] });
  99         }
 100
 101         choose { arg time;
 102                 ^envs.choose[time]
 103         }
 104
 105 }