MarkSlee.pde

   1 class SpaceTime extends SCPattern {
   2
   3   SinLFO pos = new SinLFO(0, 15, 3000);
   4   SinLFO rate = new SinLFO(1000, 9000, 13000);
   5   SinLFO falloff = new SinLFO(10, 70, 5000);
   6   float angle = 0;
   7
   8   BasicParameter rateParameter = new BasicParameter("RATE", 0.5);
   9   BasicParameter sizeParameter = new BasicParameter("SIZE", 0.5);
  10
  11   public SpaceTime(GLucose glucose) {
  12     super(glucose);
  13     addModulator(pos).trigger();
  14     addModulator(rate).trigger();
  15     addModulator(falloff).trigger();
  16     pos.modulateDurationBy(rate);
  17     addParameter(rateParameter);
  18     addParameter(sizeParameter);
  19   }
  20
  21   public void onParameterChanged(LXParameter parameter) {
  22     if (parameter == rateParameter) {
  23       rate.stop().setValue(9000 - 8000*parameter.getValuef());
  24     }  else if (parameter == sizeParameter) {
  25       falloff.stop().setValue(70 - 60*parameter.getValuef());
  26     }
  27   }
  28
  29   void run(int deltaMs) {
  30     angle += deltaMs * 0.0007;
  31     float sVal1 = model.strips.size() * (0.5 + 0.5*sin(angle));
  32     float sVal2 = model.strips.size() * (0.5 + 0.5*cos(angle));
  33
  34     float pVal = pos.getValuef();
  35     float fVal = falloff.getValuef();
  36
  37     int s = 0;
  38     for (Strip strip : model.strips) {
  39       int i = 0;
  40       for (Point p : strip.points) {
  41         colors[p.index] = color(
  42         (lx.getBaseHuef() + 360 - p.fx*.2 + p.fy * .3) % 360,
  43         constrain(.4 * min(abs(s - sVal1), abs(s - sVal2)), 20, 100),
  44         max(0, 100 - fVal*abs(i - pVal))
  45           );
  46         ++i;
  47       }
  48       ++s;
  49     }
  50   }
  51 }
  52
  53 class Swarm extends SCPattern {
  54
  55   SawLFO offset = new SawLFO(0, 16, 1000);
  56   SinLFO rate = new SinLFO(350, 1200, 63000);
  57   SinLFO falloff = new SinLFO(15, 50, 17000);
  58   SinLFO fX = new SinLFO(0, model.xMax, 19000);
  59   SinLFO fY = new SinLFO(0, model.yMax, 11000);
  60   SinLFO hOffX = new SinLFO(0, model.xMax, 13000);
  61
  62   public Swarm(GLucose glucose) {
  63     super(glucose);
  64     addModulator(offset).trigger();
  65     addModulator(rate).trigger();
  66     addModulator(falloff).trigger();
  67     addModulator(fX).trigger();
  68     addModulator(fY).trigger();
  69     addModulator(hOffX).trigger();
  70     offset.modulateDurationBy(rate);
  71   }
  72
  73   float modDist(float v1, float v2, float mod) {
  74     v1 = v1 % mod;
  75     v2 = v2 % mod;
  76     if (v2 > v1) {
  77       return min(v2-v1, v1+mod-v2);
  78     }
  79     else {
  80       return min(v1-v2, v2+mod-v1);
  81     }
  82   }
  83
  84   void run(int deltaMs) {
  85     float s = 0;
  86     for (Strip strip : model.strips) {
  87       int i = 0;
  88       for (Point p : strip.points) {
  89         float fV = max(-1, 1 - dist(p.fx/2., p.fy, fX.getValuef()/2., fY.getValuef()) / 64.);
  90         colors[p.index] = color(
  91         (lx.getBaseHuef() + 0.3 * abs(p.fx - hOffX.getValuef())) % 360,
  92         constrain(80 + 40 * fV, 0, 100),
  93         constrain(100 - (30 - fV * falloff.getValuef()) * modDist(i + (s*63)%61, offset.getValuef(), 16), 0, 100)
  94           );
  95         ++i;
  96       }
  97       ++s;
  98     }
  99   }
 100 }
 101
 102 class SwipeTransition extends SCTransition {
 103
 104   final BasicParameter bleed = new BasicParameter("WIDTH", 0.5);
 105
 106   SwipeTransition(GLucose glucose) {
 107     super(glucose);
 108     setDuration(5000);
 109     addParameter(bleed);
 110   }
 111
 112   void computeBlend(int[] c1, int[] c2, double progress) {
 113     float bleedf = 10 + bleed.getValuef() * 200.;
 114     float xPos = (float) (-bleedf + progress * (model.xMax + bleedf));
 115     for (Point p : model.points) {
 116       float d = (p.fx - xPos) / bleedf;
 117       if (d < 0) {
 118         colors[p.index] = c2[p.index];
 119       } else if (d > 1) {
 120         colors[p.index] = c1[p.index];
 121       } else {
 122         colors[p.index] = lerpColor(c2[p.index], c1[p.index], d, RGB);
 123       }
 124     }
 125   }
 126 }
 127
 128 class CubeEQ extends SCPattern {
 129
 130   private FFT fft = null;
 131   private LinearEnvelope[] bandVals = null;
 132   private int avgSize;
 133
 134   private final BasicParameter thrsh = new BasicParameter("LVL", 0.35);
 135   private final BasicParameter range = new BasicParameter("RANG", 0.45);
 136   private final BasicParameter edge = new BasicParameter("EDGE", 0.5);
 137   private final BasicParameter speed = new BasicParameter("SPD", 0.5);
 138   private final BasicParameter tone = new BasicParameter("TONE", 0.5);
 139   private final BasicParameter clr = new BasicParameter("CLR", 0.5);
 140
 141   public CubeEQ(GLucose glucose) {
 142     super(glucose);
 143     addParameter(thrsh);
 144     addParameter(range);
 145     addParameter(edge);
 146     addParameter(speed);
 147     addParameter(tone);
 148     addParameter(clr);
 149   }
 150
 151   protected void onActive() {
 152     if (this.fft == null) {
 153       this.fft = new FFT(lx.audioInput().bufferSize(), lx.audioInput().sampleRate());
 154       this.fft.window(FFT.HAMMING);
 155       this.fft.logAverages(40, 1);
 156       this.avgSize = this.fft.avgSize();
 157       this.bandVals = new LinearEnvelope[this.avgSize];
 158       for (int i = 0; i < this.bandVals.length; ++i) {
 159         this.addModulator(this.bandVals[i] = (new LinearEnvelope(0, 0, 700+i*4))).trigger();
 160       }
 161     }
 162   }
 163
 164   public void run(int deltaMs) {
 165     this.fft.forward(this.lx.audioInput().mix);
 166     float toneConst = .35 + .4 * (tone.getValuef() - 0.5);
 167     float edgeConst = 2 + 30*(edge.getValuef()*edge.getValuef()*edge.getValuef());
 168
 169     for (int i = 0; i < avgSize; ++i) {
 170       float value = this.fft.getAvg(i);
 171       value = 20*log(1 + sqrt(value));
 172       float sqdist = avgSize - i;
 173       value -= toneConst*sqdist*sqdist + .5*sqdist;
 174       value *= 6;
 175       if (value > this.bandVals[i].getValue()) {
 176         this.bandVals[i].setEndVal(value, 40).trigger();
 177       }
 178       else {
 179         this.bandVals[i].setEndVal(value, 1000 - 900*speed.getValuef()).trigger();
 180       }
 181     }
 182
 183     float jBase = 120 - 360*thrsh.getValuef();
 184     float jConst = 300.*(1-range.getValuef());
 185     float clrConst = 1.1 + clr.getValuef();
 186
 187     for (Point p : model.points) {
 188       float avgIndex = constrain((p.fx / model.xMax * avgSize), 0, avgSize-2);
 189       int avgFloor = (int) avgIndex;
 190       float j = jBase + jConst * (p.fy / model.yMax);
 191       float value = lerp(
 192       this.bandVals[avgFloor].getValuef(),
 193       this.bandVals[avgFloor+1].getValuef(),
 194       avgIndex-avgFloor
 195         );
 196
 197       float b = constrain(edgeConst * (value - j), 0, 100);
 198       colors[p.index] = color(
 199       (480 + lx.getBaseHuef() - min(clrConst*p.fy, 120)) % 360,
 200       100,
 201       b);
 202     }
 203   }
 204 }
 205
 206 class BoomEffect extends SCEffect {
 207
 208   final BasicParameter falloff = new BasicParameter("WIDTH", 0.5);
 209   final BasicParameter speed = new BasicParameter("SPD", 0.5);
 210   final BasicParameter bright = new BasicParameter("BRT", 1.0);
 211   final BasicParameter sat = new BasicParameter("SAT", 0.2);
 212   List<Layer> layers = new ArrayList<Layer>();
 213   final float maxr = sqrt(model.xMax*model.xMax + model.yMax*model.yMax + model.zMax*model.zMax) + 10;
 214
 215   class Layer {
 216     LinearEnvelope boom = new LinearEnvelope(-40, 500, 1300);
 217
 218     Layer() {
 219       addModulator(boom);
 220       trigger();
 221     }
 222
 223     void trigger() {
 224       float falloffv = falloffv();
 225       boom.setRange(-100 / falloffv, maxr + 100/falloffv, 4000 - speed.getValuef() * 3300);
 226       boom.trigger();
 227     }
 228
 229     void doApply(int[] colors) {
 230       float brightv = 100 * bright.getValuef();
 231       float falloffv = falloffv();
 232       float satv = sat.getValuef() * 100;
 233       float huev = lx.getBaseHuef();
 234       for (Point p : model.points) {
 235         colors[p.index] = blendColor(
 236         colors[p.index],
 237         color(huev, satv, constrain(brightv - falloffv*abs(boom.getValuef() - dist(p.fx, 2*p.fy, 3*p.fz, model.xMax/2, model.yMax, model.zMax*1.5)), 0, 100)),
 238         ADD);
 239       }
 240     }
 241   }
 242
 243   BoomEffect(GLucose glucose) {
 244     super(glucose, true);
 245     addParameter(falloff);
 246     addParameter(speed);
 247     addParameter(bright);
 248     addParameter(sat);
 249   }
 250
 251   public void onEnable() {
 252     for (Layer l : layers) {
 253       if (!l.boom.isRunning()) {
 254         l.trigger();
 255         return;
 256       }
 257     }
 258     layers.add(new Layer());
 259   }
 260
 261   private float falloffv() {
 262     return 20 - 19 * falloff.getValuef();
 263   }
 264
 265   public void onTrigger() {
 266     onEnable();
 267   }
 268
 269   public void doApply(int[] colors) {
 270     for (Layer l : layers) {
 271       if (l.boom.isRunning()) {
 272         l.doApply(colors);
 273       }
 274     }
 275   }
 276 }
 277
 278 public class PianoKeyPattern extends SCPattern {
 279
 280   final LinearEnvelope[] cubeBrt;
 281   final SinLFO base[];
 282   final BasicParameter attack = new BasicParameter("ATK", 0.1);
 283   final BasicParameter release = new BasicParameter("REL", 0.5);
 284   final BasicParameter level = new BasicParameter("AMB", 0.6);
 285
 286   PianoKeyPattern(GLucose glucose) {
 287     super(glucose);
 288
 289     for (MidiInputDevice input : RWMidi.getInputDevices()) {
 290       input.createInput(this);
 291     }
 292
 293     addParameter(attack);
 294     addParameter(release);
 295     addParameter(level);
 296     cubeBrt = new LinearEnvelope[model.cubes.size() / 4];
 297     for (int i = 0; i < cubeBrt.length; ++i) {
 298       addModulator(cubeBrt[i] = new LinearEnvelope(0, 0, 100));
 299     }
 300     base = new SinLFO[model.cubes.size() / 12];
 301     for (int i = 0; i < base.length; ++i) {
 302       addModulator(base[i] = new SinLFO(0, 1, 7000 + 1000*i)).trigger();
 303     }
 304   }
 305
 306   private float getAttackTime() {
 307     return 15 + attack.getValuef()*attack.getValuef() * 2000;
 308   }
 309
 310   private float getReleaseTime() {
 311     return 15 + release.getValuef() * 3000;
 312   }
 313
 314   private LinearEnvelope getEnvelope(int index) {
 315     return cubeBrt[index % cubeBrt.length];
 316   }
 317
 318   private SinLFO getBase(int index) {
 319     return base[index % base.length];
 320   }
 321
 322   public void noteOnReceived(Note note) {
 323     LinearEnvelope env = getEnvelope(note.getPitch());
 324     env.setEndVal(min(1, env.getValuef() + (note.getVelocity() / 127.)), getAttackTime()).start();
 325   }
 326
 327   public void noteOffReceived(Note note) {
 328     getEnvelope(note.getPitch()).setEndVal(0, getReleaseTime()).start();
 329   }
 330
 331   public void run(int deltaMs) {
 332     int i = 0;
 333     float huef = lx.getBaseHuef();
 334     float levelf = level.getValuef();
 335     for (Cube c : model.cubes) {
 336       float v = max(getBase(i).getValuef() * levelf/4., getEnvelope(i++).getValuef());
 337       setColor(c, color(
 338         (huef + 20*v + abs(c.cx-model.xMax/2.)*.3 + c.cy) % 360,
 339         min(100, 120*v),
 340         100*v
 341       ));
 342     }
 343   }
 344 }
 345
 346 class CrossSections extends SCPattern {
 347
 348   final SinLFO x = new SinLFO(0, model.xMax, 5000);
 349   final SinLFO y = new SinLFO(0, model.yMax, 6000);
 350   final SinLFO z = new SinLFO(0, model.zMax, 7000);
 351
 352   final BasicParameter xw = new BasicParameter("XWID", 0.3);
 353   final BasicParameter yw = new BasicParameter("YWID", 0.3);
 354   final BasicParameter zw = new BasicParameter("ZWID", 0.3);
 355   final BasicParameter xr = new BasicParameter("XRAT", 0.7);
 356   final BasicParameter yr = new BasicParameter("YRAT", 0.6);
 357   final BasicParameter zr = new BasicParameter("ZRAT", 0.5);
 358   final BasicParameter xl = new BasicParameter("XLEV", 1);
 359   final BasicParameter yl = new BasicParameter("YLEV", 1);
 360   final BasicParameter zl = new BasicParameter("ZLEV", 0.5);
 361
 362
 363   CrossSections(GLucose glucose) {
 364     super(glucose);
 365     addModulator(x).trigger();
 366     addModulator(y).trigger();
 367     addModulator(z).trigger();
 368     addParams();
 369   }
 370
 371   public void addParams()
 372   {
 373     addParameter(xr);
 374     addParameter(yr);
 375     addParameter(zr);
 376     addParameter(xw);
 377     addParameter(xl);
 378     addParameter(yl);
 379     addParameter(zl);
 380     addParameter(yw);
 381     addParameter(zw);
 382   }
 383
 384   public void onParameterChanged(LXParameter p) {
 385     if (p == xr) {
 386       x.setDuration(10000 - 8800*p.getValuef());
 387     } else if (p == yr) {
 388       y.setDuration(10000 - 9000*p.getValuef());
 389     } else if (p == zr) {
 390       z.setDuration(10000 - 9000*p.getValuef());
 391     }
 392   }
 393
 394   float xv;
 395   float yv;
 396   float zv;
 397
 398   public void updateXYZVals()
 399   {
 400     xv = x.getValuef();
 401     yv = y.getValuef();
 402     zv = z.getValuef();
 403   }
 404
 405   public void run(int deltaMs) {
 406     updateXYZVals();
 407     float xlv = 100*xl.getValuef();
 408     float ylv = 100*yl.getValuef();
 409     float zlv = 100*zl.getValuef();
 410
 411     float xwv = 100. / (10 + 40*xw.getValuef());
 412     float ywv = 100. / (10 + 40*yw.getValuef());
 413     float zwv = 100. / (10 + 40*zw.getValuef());
 414
 415     for (Point p : model.points) {
 416       color c = 0;
 417       c = blendColor(c, color(
 418       (lx.getBaseHuef() + p.fx/10 + p.fy/3) % 360,
 419       constrain(140 - 1.1*abs(p.fx - model.xMax/2.), 0, 100),
 420       max(0, xlv - xwv*abs(p.fx - xv))
 421         ), ADD);
 422       c = blendColor(c, color(
 423       (lx.getBaseHuef() + 80 + p.fy/10) % 360,
 424       constrain(140 - 2.2*abs(p.fy - model.yMax/2.), 0, 100),
 425       max(0, ylv - ywv*abs(p.fy - yv))
 426         ), ADD);
 427       c = blendColor(c, color(
 428       (lx.getBaseHuef() + 160 + p.fz / 10 + p.fy/2) % 360,
 429       constrain(140 - 2.2*abs(p.fz - model.zMax/2.), 0, 100),
 430       max(0, zlv - zwv*abs(p.fz - zv))
 431         ), ADD);
 432       colors[p.index] = c;
 433     }
 434   }
 435 }
 436
 437 class Blinders extends SCPattern {
 438
 439   final SinLFO[] m;
 440   final TriangleLFO r;
 441   final SinLFO s;
 442   final TriangleLFO hs;
 443
 444   public Blinders(GLucose glucose) {
 445     super(glucose);
 446     m = new SinLFO[12];
 447     for (int i = 0; i < m.length; ++i) {
 448       addModulator(m[i] = new SinLFO(0.5, 120, (120000. / (3+i)))).trigger();
 449     }
 450     addModulator(r = new TriangleLFO(9000, 15000, 29000)).trigger();
 451     addModulator(s = new SinLFO(-20, 275, 11000)).trigger();
 452     addModulator(hs = new TriangleLFO(0.1, 0.5, 15000)).trigger();
 453     s.modulateDurationBy(r);
 454   }
 455
 456   public void run(int deltaMs) {
 457     float hv = lx.getBaseHuef();
 458     int si = 0;
 459     for (Strip strip : model.strips) {
 460       int i = 0;
 461       float mv = m[si % m.length].getValuef();
 462       for (Point p : strip.points) {
 463         colors[p.index] = color(
 464           (hv + p.fz + p.fy*hs.getValuef()) % 360,
 465           min(100, abs(p.fx - s.getValuef())/2.),
 466           max(0, 100 - mv/2. - mv * abs(i - 7.5))
 467         );
 468         ++i;
 469       }
 470       ++si;
 471     }
 472   }
 473 }
 474
 475 class Psychedelia extends SCPattern {
 476
 477   final int NUM = 3;
 478   SinLFO m = new SinLFO(-0.5, NUM-0.5, 9000);
 479   SinLFO s = new SinLFO(-20, 147, 11000);
 480   TriangleLFO h = new TriangleLFO(0, 240, 19000);
 481   SinLFO c = new SinLFO(-.2, .8, 31000);
 482
 483   Psychedelia(GLucose glucose) {
 484     super(glucose);
 485     addModulator(m).trigger();
 486     addModulator(s).trigger();
 487     addModulator(h).trigger();
 488     addModulator(c).trigger();
 489   }
 490
 491   void run(int deltaMs) {
 492     float huev = h.getValuef();
 493     float cv = c.getValuef();
 494     float sv = s.getValuef();
 495     float mv = m.getValuef();
 496     int i = 0;
 497     for (Strip strip : model.strips) {
 498       for (Point p : strip.points) {
 499         colors[p.index] = color(
 500           (huev + i*constrain(cv, 0, 2) + p.fz/2. + p.fx/4.) % 360,
 501           min(100, abs(p.fy-sv)),
 502           max(0, 100 - 50*abs((i%NUM) - mv))
 503         );
 504       }
 505       ++i;
 506     }
 507   }
 508 }
 509
 510 class AskewPlanes extends SCPattern {
 511
 512   class Plane {
 513     private final SinLFO a;
 514     private final SinLFO b;
 515     private final SinLFO c;
 516     float av = 1;
 517     float bv = 1;
 518     float cv = 1;
 519     float denom = 0.1;
 520
 521     Plane(int i) {
 522       addModulator(a = new SinLFO(-1, 1, 4000 + 1029*i)).trigger();
 523       addModulator(b = new SinLFO(-1, 1, 11000 - 1104*i)).trigger();
 524       addModulator(c = new SinLFO(-50, 50, 4000 + 1000*i * ((i % 2 == 0) ? 1 : -1))).trigger();
 525     }
 526
 527     void run(int deltaMs) {
 528       av = a.getValuef();
 529       bv = b.getValuef();
 530       cv = c.getValuef();
 531       denom = sqrt(av*av + bv*bv);
 532     }
 533   }
 534
 535   final Plane[] planes;
 536   final int NUM_PLANES = 3;
 537
 538   AskewPlanes(GLucose glucose) {
 539     super(glucose);
 540     planes = new Plane[NUM_PLANES];
 541     for (int i = 0; i < planes.length; ++i) {
 542       planes[i] = new Plane(i);
 543     }
 544   }
 545
 546   public void run(int deltaMs) {
 547     float huev = lx.getBaseHuef();
 548
 549     // This is super fucking bizarre. But if this is a for loop, the framerate
 550     // tanks to like 30FPS, instead of 60. Call them manually and it works fine.
 551     // Doesn't make ANY sense... there must be some weird side effect going on
 552     // with the Processing internals perhaps?
 553 //    for (Plane plane : planes) {
 554 //      plane.run(deltaMs);
 555 //    }
 556     planes[0].run(deltaMs);
 557     planes[1].run(deltaMs);
 558     planes[2].run(deltaMs);
 559
 560     for (Point p : model.points) {
 561       float d = MAX_FLOAT;
 562       for (Plane plane : planes) {
 563         if (plane.denom != 0) {
 564           d = min(d, abs(plane.av*(p.fx-model.cx) + plane.bv*(p.fy-model.cy) + plane.cv) / plane.denom);
 565         }
 566       }
 567       colors[p.index] = color(
 568         (huev + abs(p.fx-model.cx)*.3 + p.fy*.8) % 360,
 569         max(0, 100 - .8*abs(p.fx - model.cx)),
 570         constrain(140 - 10.*d, 0, 100)
 571       );
 572     }
 573   }
 574 }
 575
 576 class ShiftingPlane extends SCPattern {
 577
 578   final SinLFO a = new SinLFO(-.2, .2, 5300);
 579   final SinLFO b = new SinLFO(1, -1, 13300);
 580   final SinLFO c = new SinLFO(-1.4, 1.4, 5700);
 581   final SinLFO d = new SinLFO(-10, 10, 9500);
 582
 583   ShiftingPlane(GLucose glucose) {
 584     super(glucose);
 585     addModulator(a).trigger();
 586     addModulator(b).trigger();
 587     addModulator(c).trigger();
 588     addModulator(d).trigger();
 589   }
 590
 591   public void run(int deltaMs) {
 592     float hv = lx.getBaseHuef();
 593     float av = a.getValuef();
 594     float bv = b.getValuef();
 595     float cv = c.getValuef();
 596     float dv = d.getValuef();
 597     float denom = sqrt(av*av + bv*bv + cv*cv);
 598     for (Point p : model.points) {
 599       float d = abs(av*(p.fx-model.cx) + bv*(p.fy-model.cy) + cv*(p.fz-model.cz) + dv) / denom;
 600       colors[p.index] = color(
 601         (hv + abs(p.fx-model.cx)*.6 + abs(p.fy-model.cy)*.9 + abs(p.fz - model.cz)) % 360,
 602         constrain(110 - d*6, 0, 100),
 603         constrain(130 - 7*d, 0, 100)
 604       );
 605     }
 606   }
 607 }
 608