X-Git-Url: https://git.piment-noir.org/?p=SugarCubes.git;a=blobdiff_plain;f=MarkSlee.pde;h=142399435ee376e99ce4b4f244673600a24be4b6;hp=0eb12acd943dc3c0b25d8a167fb1dfcd6b90368e;hb=dde759833df1c0190d9d3a982a90c0a4f8d76a26;hpb=19d16a168003953f5abcb90d73849673d3d06f16

diff --git a/MarkSlee.pde b/MarkSlee.pde
index 0eb12ac..1423994 100644
--- a/MarkSlee.pde
+++ b/MarkSlee.pde
@@ -1,18 +1,128 @@
+class Cathedrals extends SCPattern {
+  
+  private final BasicParameter xpos = new BasicParameter("XPOS", 0.5);
+  private final BasicParameter wid = new BasicParameter("WID", 0.5);
+  private final BasicParameter arms = new BasicParameter("ARMS", 0.5);
+  private final BasicParameter sat = new BasicParameter("SAT", 0.5);
+  private GraphicEQ eq;
+  
+  Cathedrals(LX lx) {
+    super(lx);
+    addParameter(xpos);
+    addParameter(wid);
+    addParameter(arms);
+    addParameter(sat);
+  }
+ 
+  void onActive() {
+    if (eq == null) {
+      eq = new GraphicEQ(lx, 16);
+      eq.slope.setValue(0.7);
+      eq.range.setValue(0.4);
+      eq.attack.setValue(0.4);
+      eq.release.setValue(0.4);
+      addParameter(eq.level);
+      addParameter(eq.range);
+      addParameter(eq.attack);
+      addParameter(eq.release);
+      addParameter(eq.slope);
+    }
+  }
+
+ 
+  public void run(double deltaMs) {
+    eq.run(deltaMs);
+    float bassLevel = eq.getAverageLevel(0, 4);
+    float trebleLevel = eq.getAverageLevel(8, 6);
+    
+    float falloff = 100 / (2 + 14*wid.getValuef());
+    float cx = model.xMin + (model.xMax-model.xMin) * xpos.getValuef();
+    float barm = 12 + 60*arms.getValuef()*max(0, 2*(bassLevel-0.1));
+    float tarm = 12 + 60*arms.getValuef()*max(0, 2*(trebleLevel-0.1));
+    
+    float arm = 0;
+    float middle = 0;
+    
+    float sf = 100. / (70 - 69.9*sat.getValuef());
+
+    for (LXPoint p : model.points) {
+      float d = MAX_FLOAT;
+      if (p.y > model.cy) {
+        arm = tarm;
+        middle = model.yMax * 3/5.;
+      } else {
+        arm = barm;
+        middle = model.yMax * 1/5.;
+      }
+      if (abs(p.x - cx) < arm) {
+        d = min(abs(p.x - cx), abs(p.y - middle));
+      }
+      colors[p.index] = lx.hsb(
+        (lx.getBaseHuef() + .2*abs(p.y - model.cy)) % 360,
+        min(100, sf*dist(abs(p.x - cx), p.y, arm, middle)),
+        constrain(120 - d*falloff, 0, 100));
+    }
+  } 
+}
+  
 class MidiMusic extends SCPattern {
   
+  private final Stack<LXLayer> newLayers = new Stack<LXLayer>();
+  
   private final Map<Integer, LightUp> lightMap = new HashMap<Integer, LightUp>();
-  private final List<LightUp> allLights = new ArrayList<LightUp>();
+  private final List<LightUp> lights = new ArrayList<LightUp>();
+  private final BasicParameter lightSize = new BasicParameter("SIZE", 0.5);
+
+  private final List<Sweep> sweeps = new ArrayList<Sweep>();
+
+  private final LinearEnvelope sparkle = new LinearEnvelope(0, 1, 500);
+  private boolean sparkleDirection = true;
+  private float sparkleBright = 100;
   
-  private final Stack<LightUp> newLayers = new Stack<LightUp>();
+  private final BasicParameter wave = new BasicParameter("WAVE", 0);
   
-  MidiMusic(GLucose glucose) {
-    super(glucose);
+  MidiMusic(LX lx) {
+    super(lx);
+    addParameter(lightSize);
+    addParameter(wave);
+    addModulator(sparkle).setValue(1);
+  }
+  
+  void onReset() {
+    for (LightUp light : lights) {
+      light.noteOff(null);
+    }
+  }
+  
+  class Sweep extends LXLayer {
+    
+    final LinearEnvelope position = new LinearEnvelope(0, 1, 1000);
+    float bright = 100;
+    float falloff = 10;
+    
+    Sweep() {
+      addModulator(position);
+    }
+    
+    public void run(double deltaMs, color[] colors) {
+      if (!position.isRunning()) {
+        return;
+      }
+      float posf = position.getValuef();
+      for (LXPoint p : model.points) {
+        colors[p.index] = blendColor(colors[p.index], lx.hsb(
+          (lx.getBaseHuef() + .2*abs(p.x - model.cx) + .2*abs(p.y - model.cy)) % 360,
+          100,
+          max(0, bright - posf*100 - falloff*abs(p.y - posf*model.yMax))
+        ), ADD);
+      }
+    }
   }
   
   class LightUp extends LXLayer {
     
-    private LinearEnvelope brt = new LinearEnvelope(0, 0, 0);
-    private Accelerator yPos = new Accelerator(0, 0, 0);
+    private final LinearEnvelope brt = new LinearEnvelope(0, 0, 0);
+    private final Accelerator yPos = new Accelerator(0, 0, 0);
     private float xPos;
     
     LightUp() {
@@ -25,8 +135,8 @@ class MidiMusic extends SCPattern {
     }
     
     void noteOn(Note note) {
-      xPos = lerp(0, model.xMax, constrain(0.5 + (note.getPitch() - 64) / 12., 0, 1));
-      yPos.setValue(lerp(20, model.yMax, note.getVelocity() / 127.));
+      xPos = lerp(0, model.xMax, constrain(0.5 + (note.getPitch() - 60) / 28., 0, 1));
+      yPos.setValue(lerp(20, model.yMax*.72, note.getVelocity() / 127.)).stop();
       brt.setRangeFromHereTo(lerp(40, 100, note.getVelocity() / 127.), 20).start();     
     }
 
@@ -41,11 +151,12 @@ class MidiMusic extends SCPattern {
         return;
       }
       float yVal = yPos.getValuef();
-      for (Point p : model.points) {
-        float b = max(0, bVal - 3*dist(p.x, p.y, xPos, yVal));
+      for (LXPoint p : model.points) {
+        float falloff = 6 - 5*lightSize.getValuef();
+        float b = max(0, bVal - falloff*dist(p.x, p.y, xPos, yVal));
         if (b > 0) {
           colors[p.index] = blendColor(colors[p.index], lx.hsb(
-            (lx.getBaseHuef() + abs(p.x - model.cx) + abs(p.y - model.cy)) % 360,
+            (lx.getBaseHuef() + .2*abs(p.x - model.cx) + .2*abs(p.y - model.cy)) % 360,
             100,
             b
           ), ADD);
@@ -54,27 +165,72 @@ class MidiMusic extends SCPattern {
     }
   }
   
-  public synchronized boolean noteOnReceived(Note note) {
-    if (note.getChannel() == 0) {
-      for (LightUp light : allLights) {
-        if (light.isAvailable()) {
-          light.noteOn(note);
-          lightMap.put(note.getPitch(), light);
-          return true;
-        }
+  private LightUp getLight() {
+    for (LightUp light : lights) {
+      if (light.isAvailable()) {
+        return light;
       }
-      LightUp newLight = new LightUp();
-      newLight.noteOn(note);
-      lightMap.put(note.getPitch(), newLight);
-      synchronized(newLayers) {
-        newLayers.push(newLight);
+    }
+    LightUp newLight = new LightUp();
+    lights.add(newLight);
+    synchronized(newLayers) {
+      newLayers.push(newLight);
+    }
+    return newLight;
+  }
+  
+  private Sweep getSweep() {
+    for (Sweep s : sweeps) {
+      if (!s.position.isRunning()) {
+        return s;
       }
+    }
+    Sweep newSweep = new Sweep();
+    sweeps.add(newSweep);
+    synchronized(newLayers) {
+      newLayers.push(newSweep);
+    }
+    return newSweep;
+  }
+  
+  public synchronized boolean noteOn(Note note) {
+    if (note.getChannel() == 0) {
+      LightUp light = getLight();
+      lightMap.put(note.getPitch(), light);
+      light.noteOn(note);
     } else if (note.getChannel() == 1) {
+    } else if (note.getChannel() == 9) {
+      if (note.getVelocity() > 0) {
+        switch (note.getPitch()) {
+          case 36:
+            Sweep s = getSweep();
+            s.bright = 50 + note.getVelocity() / 127. * 50;
+            s.falloff = 20 - note.getVelocity() / 127. * 17;
+            s.position.trigger();
+            break;
+          case 37:
+            sparkleBright = note.getVelocity() / 127. * 100;
+            sparkleDirection = true;
+            sparkle.trigger();
+            break;
+          case 38:
+            sparkleBright = note.getVelocity() / 127. * 100;
+            sparkleDirection = false;
+            sparkle.trigger();       
+            break;
+          case 39:
+            effects.boom.trigger();
+            break;
+          case 40:
+            effects.flash.trigger();
+            break;
+        }
+      }
     }
     return true;
   }
   
-  public synchronized boolean noteOffReceived(Note note) {
+  public synchronized boolean noteOff(Note note) {
     if (note.getChannel() == 0) {
       LightUp light = lightMap.get(note.getPitch());
       if (light != null) {
@@ -84,8 +240,30 @@ class MidiMusic extends SCPattern {
     return true;
   }
   
+  final float[] wval = new float[16];
+  float wavoff = 0;
+  
   public synchronized void run(double deltaMs) {
-    setColors(#000000);
+    wavoff += deltaMs * .001;
+    for (int i = 0; i < wval.length; ++i) {
+      wval[i] = model.cy + 0.2 * model.yMax/2. * sin(wavoff + i / 1.9);
+    }
+    float sparklePos = (sparkleDirection ? sparkle.getValuef() : (1 - sparkle.getValuef())) * (Cube.POINTS_PER_STRIP)/2.;
+    float maxBright = sparkleBright * (1 - sparkle.getValuef());
+    for (Strip s : model.strips) {
+      int i = 0;
+      for (LXPoint p : s.points) {
+        int wavi = (int) constrain(p.x / model.xMax * wval.length, 0, wval.length-1);
+        float wavb = max(0, wave.getValuef()*100. - 8.*abs(p.y - wval[wavi]));
+        colors[p.index] = lx.hsb(
+          (lx.getBaseHuef() + .2*abs(p.x - model.cx) + .2*abs(p.y - model.cy)) % 360,
+          100,
+          constrain(wavb + max(0, maxBright - 40.*abs(sparklePos - abs(i - (Cube.POINTS_PER_STRIP-1)/2.))), 0, 100)
+        );
+        ++i;
+      }
+    }
+        
     if (!newLayers.isEmpty()) {
       synchronized(newLayers) {
         while (!newLayers.isEmpty()) {
@@ -106,10 +284,10 @@ class Pulley extends SCPattern {
   private boolean isRising = false;
   
   private BasicParameter sz = new BasicParameter("SIZE", 0.5);
-  private BasicParameter beatAmount = new BasicParameter("BEAT", 0.1);
+  private BasicParameter beatAmount = new BasicParameter("BEAT", 0);
   
-  Pulley(GLucose glucose) {
-    super(glucose);
+  Pulley(LX lx) {
+    super(lx);
     for (int i = 0; i < NUM_DIVISIONS; ++i) {
       addModulator(gravity[i] = new Accelerator(0, 0, 0));
       addModulator(delays[i] = new Click(0));
@@ -118,6 +296,7 @@ class Pulley extends SCPattern {
     addParameter(sz);
     addParameter(beatAmount);
     trigger();
+
   }
   
   private void trigger() {
@@ -125,7 +304,7 @@ class Pulley extends SCPattern {
     int i = 0;
     for (Accelerator g : gravity) {
       if (isRising) {
-        g.setSpeed(random(40, 50), 0).start();
+        g.setSpeed(random(20, 33), 0).start();
       } else {
         g.setVelocity(0).setAcceleration(-420);
         delays[i].setDuration(random(0, 500)).trigger();
@@ -138,45 +317,61 @@ class Pulley extends SCPattern {
     if (reset.click()) {
       trigger();
     }
-    int j = 0;
-    for (Click d : delays) {
-      if (d.click()) {
-        gravity[j].start();
-        d.stop();
-      }
-      ++j;
-    }   
-    
-    for (Accelerator g : gravity) {
-      if (isRising) {
-        if (g.getValuef() > model.yMax) {
-          g.stop();
-        } else if (g.getValuef() > model.yMax*.55) {
-          if (g.getVelocityf() > 10) {
-            g.setAcceleration(-16);
-          } else {
-            g.setAcceleration(0);
-          }
+        
+    if (isRising) {
+      // Fucking A, had to comment this all out because of that bizarre
+      // Processing bug where some simple loop takes an absurd amount of
+      // time, must be some pre-processor bug
+//      for (Accelerator g : gravity) {
+//        if (g.getValuef() > model.yMax) {
+//          g.stop();
+//        } else if (g.getValuef() > model.yMax*.55) {
+//          if (g.getVelocityf() > 10) {
+//            g.setAcceleration(-16);
+//          } else {
+//            g.setAcceleration(0);
+//          }
+//        }
+//      }
+    } else {
+      int j = 0;
+      for (Click d : delays) {
+        if (d.click()) {
+          gravity[j].start();
+          d.stop();
         }
-      } else {
+        ++j;
+      }
+      for (Accelerator g : gravity) {
         if (g.getValuef() < 0) {
           g.setValue(-g.getValuef());
           g.setVelocity(-g.getVelocityf() * random(0.74, 0.84));
         }
       }
     }
+
+    // A little silliness to test the grid API    
+    if (midiEngine != null && midiEngine.getFocusedPattern() == this) {
+	    for (int i = 0; i < 5; ++i) {
+        for (int j = 0; j < 8; ++j) {
+          int gi = (int) constrain(j * NUM_DIVISIONS / 8, 0, NUM_DIVISIONS-1);
+          float b = 1 - 4.*abs((6-i)/6. - gravity[gi].getValuef() / model.yMax);
+          midiEngine.grid.setState(i, j, (b < 0) ? 0 : 3);
+        }
+      }
+    }
     
     float fPos = 1 - lx.tempo.rampf();
     if (fPos < .2) {
       fPos = .2 + 4 * (.2 - fPos);
     }
     float falloff = 100. / (3 + sz.getValuef() * 36 + fPos * beatAmount.getValuef()*48);
-    for (Point p : model.points) {
-      int g = (int) constrain((p.x - model.xMin) * NUM_DIVISIONS / (model.xMax - model.xMin), 0, NUM_DIVISIONS-1);
+    for (LXPoint p : model.points) {
+      int gi = (int) constrain((p.x - model.xMin) * NUM_DIVISIONS / (model.xMax - model.xMin), 0, NUM_DIVISIONS-1);
       colors[p.index] = lx.hsb(
         (lx.getBaseHuef() + abs(p.x - model.cx)*.8 + p.y*.4) % 360,
         constrain(130 - p.y*.8, 0, 100),
-        max(0, 100 - abs(p.y - gravity[g].getValuef())*falloff)
+        max(0, 100 - abs(p.y - gravity[gi].getValuef())*falloff)
       );
     }
   }
@@ -197,8 +392,8 @@ class ViolinWave extends SCPattern {
   
   LinearEnvelope dbValue = new LinearEnvelope(0, 0, 10);
 
-  ViolinWave(GLucose glucose) {
-    super(glucose);
+  ViolinWave(LX lx) {
+    super(lx);
     addParameter(level);
     addParameter(edge);
     addParameter(range);
@@ -243,7 +438,7 @@ class ViolinWave extends SCPattern {
       }
       
       float pFalloff = (30 - 27*pSize.getValuef());
-      for (Point p : model.points) {
+      for (LXPoint p : model.points) {
         float b = 100 - pFalloff * (abs(p.x - x.getValuef()) + abs(p.y - y.getValuef()));
         if (b > 0) {
           colors[p.index] = blendColor(colors[p.index], lx.hsb(
@@ -276,7 +471,7 @@ class ViolinWave extends SCPattern {
     }
     
     float zeroDBReference = pow(10, (50 - 190*level.getValuef())/20.);
-    float dB = 20*GraphicEQ.log10(lx.audioInput().mix.level() / zeroDBReference);    
+    float dB = 20*GraphicEQ.log10(lx.audioInput().mix.level() / zeroDBReference);
     if (dB > dbValue.getValuef()) {
       rising = true;
       dbValue.setRangeFromHereTo(dB, 10).trigger();
@@ -294,7 +489,7 @@ class ViolinWave extends SCPattern {
     float rng = (78 - 64 * range.getValuef()) / (model.yMax - model.cy);
     float val = max(2, dbValue.getValuef());
     
-    for (Point p : model.points) {
+    for (LXPoint p : model.points) {
       int ci = (int) lerp(0, centers.length-1, (p.x - model.xMin) / (model.xMax - model.xMin));
       float rFactor = 1.0 -  0.9 * abs(p.x - model.cx) / (model.xMax - model.cx);
       colors[p.index] = lx.hsb(
@@ -321,7 +516,7 @@ class BouncyBalls extends SCPattern {
     float zPos;
     
     BouncyBall(int i) {
-      addModulator(xPos).setBasis(random(0, TWO_PI)).start();
+      addModulator(xPos.setBasis(random(0, TWO_PI)).start());
       addModulator(yPos = new Accelerator(0, 0, 0));
       zPos = lerp(model.zMin, model.zMax, (i+2.) / (NUM_BALLS + 4.));
     }
@@ -350,7 +545,7 @@ class BouncyBalls extends SCPattern {
       float xv = xPos.getValuef();
       float yv = yPos.getValuef();
       
-      for (Point p : model.points) {
+      for (LXPoint p : model.points) {
         float d = sqrt((p.x-xv)*(p.x-xv) + (p.y-yv)*(p.y-yv) + .1*(p.z-zPos)*(p.z-zPos));
         float b = constrain(130 - falloff*d, 0, 100);
         if (b > 0) {
@@ -370,8 +565,8 @@ class BouncyBalls extends SCPattern {
   final BasicParameter flr = new BasicParameter("FLR", 0);
   final BasicParameter blobSize = new BasicParameter("SIZE", 0.5);
   
-  BouncyBalls(GLucose glucose) {
-    super(glucose);
+  BouncyBalls(LX lx) {
+    super(lx);
     for (int i = 0; i < balls.length; ++i) {
       balls[i] = new BouncyBall(i);
     }
@@ -387,7 +582,7 @@ class BouncyBalls extends SCPattern {
     }
   }
   
-  public boolean noteOnReceived(Note note) {
+  public boolean noteOn(Note note) {
     int pitch = (note.getPitch() + note.getChannel()) % NUM_BALLS;
     balls[pitch].bounce(note.getVelocity());
     return true;
@@ -405,8 +600,8 @@ class SpaceTime extends SCPattern {
   BasicParameter sizeParameter = new BasicParameter("SIZE", 0.5);
 
 
-  public SpaceTime(GLucose glucose) {
-    super(glucose);
+  public SpaceTime(LX lx) {
+    super(lx);
     
     addModulator(pos).trigger();
     addModulator(rate).trigger();
@@ -435,7 +630,7 @@ class SpaceTime extends SCPattern {
     int s = 0;
     for (Strip strip : model.strips) {
       int i = 0;
-      for (Point p : strip.points) {
+      for (LXPoint p : strip.points) {
         colors[p.index] = lx.hsb(
           (lx.getBaseHuef() + 360 - p.x*.2 + p.y * .3) % 360, 
           constrain(.4 * min(abs(s - sVal1), abs(s - sVal2)), 20, 100),
@@ -449,16 +644,16 @@ class SpaceTime extends SCPattern {
 }
 
 class Swarm extends SCPattern {
-
+  
   SawLFO offset = new SawLFO(0, 1, 1000);
   SinLFO rate = new SinLFO(350, 1200, 63000);
   SinLFO falloff = new SinLFO(15, 50, 17000);
-  SinLFO fX = new SinLFO(0, model.xMax, 19000);
-  SinLFO fY = new SinLFO(0, model.yMax, 11000);
-  SinLFO hOffX = new SinLFO(0, model.xMax, 13000);
+  SinLFO fX = new SinLFO(model.xMin, model.xMax, 19000);
+  SinLFO fY = new SinLFO(model.yMin, model.yMax, 11000);
+  SinLFO hOffX = new SinLFO(model.xMin, model.xMax, 13000);
 
-  public Swarm(GLucose glucose) {
-    super(glucose);
+  public Swarm(LX lx) {
+    super(lx);
     
     addModulator(offset).trigger();
     addModulator(rate).trigger();
@@ -482,28 +677,29 @@ class Swarm extends SCPattern {
 
   void run(double deltaMs) {
     float s = 0;
-    for (Strip strip : model.strips  ) {
+    for (Strip strip : model.strips) {
       int i = 0;
-      for (Point p : strip.points) {
+      for (LXPoint p : strip.points) {
         float fV = max(-1, 1 - dist(p.x/2., p.y, fX.getValuef()/2., fY.getValuef()) / 64.);
         colors[p.index] = lx.hsb(
         (lx.getBaseHuef() + 0.3 * abs(p.x - hOffX.getValuef())) % 360, 
         constrain(80 + 40 * fV, 0, 100), 
-        constrain(100 - (30 - fV * falloff.getValuef()) * modDist(i + (s*63)%61, offset.getValuef() * strip.metrics.numPoints, strip.metrics.numPoints), 0, 100)
+        constrain(100 - 
+          (30 - fV * falloff.getValuef()) * modDist(i + (s*63)%61, offset.getValuef() * strip.metrics.numPoints, strip.metrics.numPoints), 0, 100)
           );
         ++i;
-      }
+      } 
       ++s;
     }
   }
 }
 
-class SwipeTransition extends SCTransition {
+class SwipeTransition extends LXTransition {
   
   final BasicParameter bleed = new BasicParameter("WIDTH", 0.5);
   
-  SwipeTransition(GLucose glucose) {
-    super(glucose);
+  SwipeTransition(LX lx) {
+    super(lx);
     setDuration(5000);
     addParameter(bleed);
   }
@@ -511,7 +707,7 @@ class SwipeTransition extends SCTransition {
   void computeBlend(int[] c1, int[] c2, double progress) {
     float bleedf = 10 + bleed.getValuef() * 200.;
     float xPos = (float) (-bleedf + progress * (model.xMax + bleedf));
-    for (Point p : model.points) {
+    for (LXPoint p : model.points) {
       float d = (p.x - xPos) / bleedf;
       if (d < 0) {
         colors[p.index] = c2[p.index];
@@ -524,95 +720,22 @@ class SwipeTransition extends SCTransition {
   }
 }
 
-abstract class BlendTransition extends SCTransition {
-  
-  final int blendType;
-  
-  BlendTransition(GLucose glucose, int blendType) {
-    super(glucose);
-    this.blendType = blendType;
-  }
-
-  void computeBlend(int[] c1, int[] c2, double progress) {
-    if (progress < 0.5) {
-      for (int i = 0; i < c1.length; ++i) {
-        colors[i] = lerpColor(
-          c1[i],
-          blendColor(c1[i], c2[i], blendType),
-          (float) (2.*progress),
-          RGB);
-      }
-    } else {
-      for (int i = 0; i < c1.length; ++i) {
-        colors[i] = lerpColor(
-          c2[i],
-          blendColor(c1[i], c2[i], blendType),
-          (float) (2.*(1. - progress)),
-          RGB);
-      }
-    }
-  }
-}
-
-class MultiplyTransition extends BlendTransition {
-  MultiplyTransition(GLucose glucose) {
-    super(glucose, MULTIPLY);
-  }
-}
-
-class ScreenTransition extends BlendTransition {
-  ScreenTransition(GLucose glucose) {
-    super(glucose, SCREEN);
-  }
-}
-
-class BurnTransition extends BlendTransition {
-  BurnTransition(GLucose glucose) {
-    super(glucose, BURN);
-  }
-}
-
-class DodgeTransition extends BlendTransition {
-  DodgeTransition(GLucose glucose) {
-    super(glucose, DODGE);
-  }
-}
-
-class OverlayTransition extends BlendTransition {
-  OverlayTransition(GLucose glucose) {
-    super(glucose, OVERLAY);
-  }
-}
-
-class AddTransition extends BlendTransition {
-  AddTransition(GLucose glucose) {
-    super(glucose, ADD);
-  }
-}
-
-class SubtractTransition extends BlendTransition {
-  SubtractTransition(GLucose glucose) {
-    super(glucose, SUBTRACT);
-  }
-}
-
-class SoftLightTransition extends BlendTransition {
-  SoftLightTransition(GLucose glucose) {
-    super(glucose, SOFT_LIGHT);
-  }
-}
-
 class BassPod extends SCPattern {
 
   private GraphicEQ eq = null;
   
-  public BassPod(GLucose glucose) {
-    super(glucose);
+  private final BasicParameter clr = new BasicParameter("CLR", 0.5);
+  
+  public BassPod(LX lx) {
+    super(lx);
+    addParameter(clr);
   }
   
-  protected void onActive() {
+  void onActive() {
     if (eq == null) {
       eq = new GraphicEQ(lx, 16);
+      eq.range.setValue(0.4);
+      eq.level.setValue(0.4);
       eq.slope.setValue(0.6);
       addParameter(eq.level);
       addParameter(eq.range);
@@ -627,8 +750,10 @@ class BassPod extends SCPattern {
     
     float bassLevel = eq.getAverageLevel(0, 5);
     
-    for (Point p : model.points) {
-      int avgIndex = (int) constrain(1 + abs(p.x-model.xMax/2.)/(model.xMax/2.)*(eq.numBands-5), 0, eq.numBands-5);
+    float satBase = bassLevel*480*clr.getValuef();
+    
+    for (LXPoint p : model.points) {
+      int avgIndex = (int) constrain(1 + abs(p.x-model.cx)/(model.cx)*(eq.numBands-5), 0, eq.numBands-5);
       float value = 0;
       for (int i = avgIndex; i < avgIndex + 5; ++i) {
         value += eq.getLevel(i);
@@ -638,7 +763,7 @@ class BassPod extends SCPattern {
       float b = constrain(8 * (value*model.yMax - abs(p.y-model.yMax/2.)), 0, 100);
       colors[p.index] = lx.hsb(
         (lx.getBaseHuef() + abs(p.y - model.cy) + abs(p.x - model.cx)) % 360,
-        constrain(bassLevel*240 - .6*dist(p.x, p.y, model.cx, model.cy), 0, 100),
+        constrain(satBase - .6*dist(p.x, p.y, model.cx, model.cy), 0, 100),
         b
       );
     }
@@ -654,11 +779,11 @@ class CubeEQ extends SCPattern {
   private final BasicParameter clr = new BasicParameter("CLR", 0.5);
   private final BasicParameter blockiness = new BasicParameter("BLK", 0.5);
 
-  public CubeEQ(GLucose glucose) {
-    super(glucose);
+  public CubeEQ(LX lx) {
+    super(lx);
   }
 
-  protected void onActive() {
+  void onActive() {
     if (eq == null) {
       eq = new GraphicEQ(lx, 16);
       addParameter(eq.level);
@@ -678,7 +803,7 @@ class CubeEQ extends SCPattern {
     float edgeConst = 2 + 30*edge.getValuef();
     float clrConst = 1.1 + clr.getValuef();
 
-    for (Point p : model.points) {
+    for (LXPoint p : model.points) {
       float avgIndex = constrain(2 + p.x / model.xMax * (eq.numBands-4), 0, eq.numBands-4);
       int avgFloor = (int) avgIndex;
 
@@ -705,7 +830,7 @@ class CubeEQ extends SCPattern {
   }
 }
 
-class BoomEffect extends SCEffect {
+class BoomEffect extends LXEffect {
 
   final BasicParameter falloff = new BasicParameter("WIDTH", 0.5);
   final BasicParameter speed = new BasicParameter("SPD", 0.5);
@@ -728,12 +853,12 @@ class BoomEffect extends SCEffect {
       boom.trigger();
     }
 
-    void doApply(int[] colors) {
+    void apply(int[] colors) {
       float brightv = 100 * bright.getValuef();
       float falloffv = falloffv();
       float satv = sat.getValuef() * 100;
       float huev = lx.getBaseHuef();
-      for (Point p : model.points) {
+      for (LXPoint p : model.points) {
         colors[p.index] = blendColor(
         colors[p.index], 
         lx.hsb(huev, satv, constrain(brightv - falloffv*abs(boom.getValuef() - dist(p.x, 2*p.y, 3*p.z, model.xMax/2, model.yMax, model.zMax*1.5)), 0, 100)), 
@@ -742,8 +867,8 @@ class BoomEffect extends SCEffect {
     }
   }
 
-  BoomEffect(GLucose glucose) {
-    super(glucose, true);
+  BoomEffect(LX lx) {
+    super(lx, true);
     addParameter(falloff);
     addParameter(speed);
     addParameter(bright);
@@ -768,10 +893,10 @@ class BoomEffect extends SCEffect {
     onEnable();
   }
 
-  public void doApply(int[] colors) {
+  public void apply(int[] colors) {
     for (Layer l : layers) {
       if (l.boom.isRunning()) {
-        l.doApply(colors);
+        l.apply(colors);
       }
     }
   }
@@ -785,8 +910,8 @@ public class PianoKeyPattern extends SCPattern {
   final BasicParameter release = new BasicParameter("REL", 0.5);
   final BasicParameter level = new BasicParameter("AMB", 0.6);
   
-  PianoKeyPattern(GLucose glucose) {
-    super(glucose);
+  PianoKeyPattern(LX lx) {
+    super(lx);
         
     addParameter(attack);
     addParameter(release);
@@ -817,13 +942,13 @@ public class PianoKeyPattern extends SCPattern {
     return base[index % base.length];
   }
     
-  public boolean noteOnReceived(Note note) {
+  public boolean noteOn(Note note) {
     LinearEnvelope env = getEnvelope(note.getPitch());
     env.setEndVal(min(1, env.getValuef() + (note.getVelocity() / 127.)), getAttackTime()).start();
     return true;
   }
   
-  public boolean noteOffReceived(Note note) {
+  public boolean noteOff(Note note) {
     getEnvelope(note.getPitch()).setEndVal(0, getReleaseTime()).start();
     return true;
   }
@@ -860,8 +985,8 @@ class CrossSections extends SCPattern {
   final BasicParameter zl = new BasicParameter("ZLEV", 0.5);
 
   
-  CrossSections(GLucose glucose) {
-    super(glucose);
+  CrossSections(LX lx) {
+    super(lx);
     addModulator(x).trigger();
     addModulator(y).trigger();
     addModulator(z).trigger();
@@ -909,7 +1034,7 @@ class CrossSections extends SCPattern {
     float ywv = 100. / (10 + 40*yw.getValuef());
     float zwv = 100. / (10 + 40*zw.getValuef());
     
-    for (Point p : model.points) {
+    for (LXPoint p : model.points) {
       color c = 0;
       c = blendColor(c, lx.hsb(
       (lx.getBaseHuef() + p.x/10 + p.y/3) % 360, 
@@ -938,8 +1063,8 @@ class Blinders extends SCPattern {
   final SinLFO s;
   final TriangleLFO hs;
 
-  public Blinders(GLucose glucose) {
-    super(glucose);
+  public Blinders(LX lx) {
+    super(lx);
     m = new SinLFO[12];
     for (int i = 0; i < m.length; ++i) {  
       addModulator(m[i] = new SinLFO(0.5, 120, (120000. / (3+i)))).trigger();
@@ -956,7 +1081,7 @@ class Blinders extends SCPattern {
     for (Strip strip : model.strips) {
       int i = 0;
       float mv = m[si % m.length].getValuef();
-      for (Point p : strip.points) {
+      for (LXPoint p : strip.points) {
         colors[p.index] = lx.hsb(
           (hv + p.z + p.y*hs.getValuef()) % 360, 
           min(100, abs(p.x - s.getValuef())/2.), 
@@ -977,8 +1102,8 @@ class Psychedelia extends SCPattern {
   TriangleLFO h = new TriangleLFO(0, 240, 19000);
   SinLFO c = new SinLFO(-.2, .8, 31000);
 
-  Psychedelia(GLucose glucose) {
-    super(glucose);
+  Psychedelia(LX lx) {
+    super(lx);
     addModulator(m).trigger();
     addModulator(s).trigger();
     addModulator(h).trigger();
@@ -992,7 +1117,7 @@ class Psychedelia extends SCPattern {
     float mv = m.getValuef();
     int i = 0;
     for (Strip strip : model.strips) {
-      for (Point p : strip.points) {
+      for (LXPoint p : strip.points) {
         colors[p.index] = lx.hsb(
           (huev + i*constrain(cv, 0, 2) + p.z/2. + p.x/4.) % 360, 
           min(100, abs(p.y-sv)), 
@@ -1032,8 +1157,8 @@ class AskewPlanes extends SCPattern {
   final Plane[] planes;
   final int NUM_PLANES = 3;
   
-  AskewPlanes(GLucose glucose) {
-    super(glucose);
+  AskewPlanes(LX lx) {
+    super(lx);
     planes = new Plane[NUM_PLANES];
     for (int i = 0; i < planes.length; ++i) {
       planes[i] = new Plane(i);
@@ -1054,7 +1179,7 @@ class AskewPlanes extends SCPattern {
     planes[1].run(deltaMs);
     planes[2].run(deltaMs);    
     
-    for (Point p : model.points) {
+    for (LXPoint p : model.points) {
       float d = MAX_FLOAT;
       for (Plane plane : planes) {
         if (plane.denom != 0) {
@@ -1077,8 +1202,8 @@ class ShiftingPlane extends SCPattern {
   final SinLFO c = new SinLFO(-1.4, 1.4, 5700);
   final SinLFO d = new SinLFO(-10, 10, 9500);
 
-  ShiftingPlane(GLucose glucose) {
-    super(glucose);
+  ShiftingPlane(LX lx) {
+    super(lx);
     addModulator(a).trigger();
     addModulator(b).trigger();
     addModulator(c).trigger();
@@ -1092,7 +1217,7 @@ class ShiftingPlane extends SCPattern {
     float cv = c.getValuef();
     float dv = d.getValuef();    
     float denom = sqrt(av*av + bv*bv + cv*cv);
-    for (Point p : model.points) {
+    for (LXPoint p : model.points) {
       float d = abs(av*(p.x-model.cx) + bv*(p.y-model.cy) + cv*(p.z-model.cz) + dv) / denom;
       colors[p.index] = lx.hsb(
         (hv + abs(p.x-model.cx)*.6 + abs(p.y-model.cy)*.9 + abs(p.z - model.cz)) % 360,
@@ -1115,8 +1240,8 @@ class Traktor extends SCPattern {
   private int index = 0;
   private GraphicEQ eq = null;
 
-  public Traktor(GLucose glucose) {
-    super(glucose);
+  public Traktor(LX lx) {
+    super(lx);
     for (int i = 0; i < FRAME_WIDTH; ++i) {
       bass[i] = 0;
       treble[i] = 0;
@@ -1159,14 +1284,14 @@ class Traktor extends SCPattern {
     bass[index] = rawBass * rawBass * rawBass * rawBass;
     treble[index] = rawTreble * rawTreble;
 
-    for (Point p : model.points) {
+    for (LXPoint p : model.points) {
       int i = (int) constrain((model.xMax - p.x) / model.xMax * FRAME_WIDTH, 0, FRAME_WIDTH-1);
       int pos = (index + FRAME_WIDTH - i) % FRAME_WIDTH;
       
       colors[p.index] = lx.hsb(
         (360 + lx.getBaseHuef() + .8*abs(p.x-model.cx)) % 360,
         100,
-        constrain(9 * (bass[pos]*model.cy - abs(p.y - model.cy)), 0, 100)
+        constrain(9 * (bass[pos]*model.cy - abs(p.y - model.cy + 5)), 0, 100)
       );
       colors[p.index] = blendColor(colors[p.index], lx.hsb(
         (400 + lx.getBaseHuef() + .5*abs(p.x-model.cx)) % 360,
@@ -1178,48 +1303,114 @@ class Traktor extends SCPattern {
   }
 }
 
-class ColorFuckerEffect extends SCEffect {
+class ColorFuckerEffect extends LXEffect {
+  
+  final BasicParameter level = new BasicParameter("BRT", 1);
+  final BasicParameter desat = new BasicParameter("DSAT", 0);
+  final BasicParameter hueShift = new BasicParameter("HSHFT", 0);
+  final BasicParameter sharp = new BasicParameter("SHARP", 0);
+  final BasicParameter soft = new BasicParameter("SOFT", 0);
+  final BasicParameter mono = new BasicParameter("MONO", 0);
+  final BasicParameter invert = new BasicParameter("INVERT", 0);
+
   
-  BasicParameter hueShift = new BasicParameter("HSHFT", 0);
-  BasicParameter sat = new BasicParameter("SAT", 1);  
-  BasicParameter bright = new BasicParameter("BRT", 1);
   float[] hsb = new float[3];
   
-  ColorFuckerEffect(GLucose glucose) {
-    super(glucose);
+  ColorFuckerEffect(LX lx) {
+    super(lx);
+    addParameter(level);
+    addParameter(desat);
+    addParameter(sharp);
     addParameter(hueShift);
-    addParameter(bright);
-    addParameter(sat);    
+    addParameter(soft);
+    addParameter(mono);
+    addParameter(invert);
   }
   
-  public void doApply(int[] colors) {
-    if (!enabled) {
+  public void apply(int[] colors) {
+    if (!isEnabled()) {
       return;
     }
-    float bMod = bright.getValuef();
-    float sMod = sat.getValuef();
+    float bMod = level.getValuef();
+    float sMod = 1 - desat.getValuef();
     float hMod = hueShift.getValuef();
-    if (bMod < 1 || sMod < 1 || hMod > 0) {    
+    float fSharp = sharp.getValuef();
+    float fSoft = soft.getValuef();
+    boolean mon = mono.getValuef() > 0.5;
+    boolean ivt = invert.getValuef() > 0.5;
+    if (bMod < 1 || sMod < 1 || hMod > 0 || fSharp > 0 || ivt || mon || fSoft > 0) {
       for (int i = 0; i < colors.length; ++i) {
         lx.RGBtoHSB(colors[i], hsb);
+        if (mon) {
+          hsb[0] = lx.getBaseHuef() / 360.;
+        }
+        if (ivt) {
+          hsb[2] = 1 - hsb[2];
+        }
+        if (fSharp > 0) {
+          fSharp = 1/(1-fSharp);
+          if (hsb[2] < .5) {
+            hsb[2] = pow(hsb[2],fSharp);
+          } else {
+            hsb[2] = 1-pow(1-hsb[2],fSharp);
+          }
+        }
+        if (fSoft > 0) {
+          if (hsb[2] > 0.5) {
+            hsb[2] = lerp(hsb[2], 0.5 + 2 * (hsb[2]-0.5)*(hsb[2]-0.5), fSoft);
+          } else {
+            hsb[2] = lerp(hsb[2], 0.5 * sqrt(2*hsb[2]), fSoft);
+          }
+        }
         colors[i] = lx.hsb(
-          (360. * hsb[0] + hueShift.getValuef()*360.) % 360,
-          100. * hsb[1] * sat.getValuef(),
-          100. * hsb[2] * bright.getValuef()
+          (360. * hsb[0] + hMod*360.) % 360,
+          100. * hsb[1] * sMod,
+          100. * hsb[2] * bMod
         );
       }
     }
   }
 }
 
-class BlurEffect extends SCEffect {
+class QuantizeEffect extends LXEffect {
+  
+  color[] quantizedFrame;
+  float lastQuant;
+  final BasicParameter amount = new BasicParameter("AMT", 0);
+  
+  QuantizeEffect(LX lx) {
+    super(lx);
+    quantizedFrame = new color[glucose.lx.total];
+    lastQuant = 0;
+  } 
+  
+  public void apply(int[] colors) {
+    float fQuant = amount.getValuef();
+    if (fQuant > 0) {
+      float tRamp = (lx.tempo.rampf() % (1./pow(2,floor((1-fQuant) * 4))));
+      float f = lastQuant;
+      lastQuant = tRamp;
+      if (tRamp > f) {
+        for (int i = 0; i < colors.length; ++i) {
+          colors[i] = quantizedFrame[i];
+        }
+        return;
+      }
+    }
+    for (int i = 0; i < colors.length; ++i) {
+      quantizedFrame[i] = colors[i];
+    }
+  }
+}
+
+class BlurEffect extends LXEffect {
   
-  final LXParameter amount = new BasicParameter("AMT", 0);
+  final BasicParameter amount = new BasicParameter("AMT", 0);
   final int[] frame;
   final LinearEnvelope env = new LinearEnvelope(0, 1, 100);
   
-  BlurEffect(GLucose glucose) {
-    super(glucose);
+  BlurEffect(LX lx) {
+    super(lx);
     addParameter(amount);
     addModulator(env);
     frame = new int[lx.total];
@@ -1239,7 +1430,7 @@ class BlurEffect extends SCEffect {
     env.setRangeFromHereTo(0, 1000).start();
   }
   
-  public void doApply(int[] colors) {
+  public void apply(int[] colors) {
     float amt = env.getValuef() * amount.getValuef();
     if (amt > 0) {    
       amt = (1 - amt);
@@ -1252,3 +1443,4 @@ class BlurEffect extends SCEffect {
       
   }  
 }
+