X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=TimBavaro.pde;h=2ca73d7475ce77a39fb4a330d9eb70aa753682bb;hb=dde759833df1c0190d9d3a982a90c0a4f8d76a26;hp=1dd062e8259181d937d75125cbc8f7bee2b96f60;hpb=d33c2d1d64234dd5f54942a9b76afaec3833c206;p=SugarCubes.git

diff --git a/TimBavaro.pde b/TimBavaro.pde
old mode 100755
new mode 100644
index 1dd062e..2ca73d7
--- a/TimBavaro.pde
+++ b/TimBavaro.pde
@@ -3,8 +3,9 @@
  */
 class TimSpheres extends SCPattern {
   private BasicParameter hueParameter = new BasicParameter("RAD", 1.0);
+  private BasicParameter periodParameter = new BasicParameter("PERIOD", 4000.0, 200.0, 10000.0);
   private final SawLFO lfo = new SawLFO(0, 1, 10000);
-  private final SinLFO sinLfo = new SinLFO(0, 1, 4000);
+  private final SinLFO sinLfo = new SinLFO(0, 1, periodParameter);
   private final float centerX, centerY, centerZ;
   
   class Sphere {
@@ -15,9 +16,10 @@ class TimSpheres extends SCPattern {
   
   private final Sphere[] spheres;
   
-  public TimSpheres(GLucose glucose) {
-    super(glucose);
+  public TimSpheres(LX lx) {
+    super(lx);
     addParameter(hueParameter);
+    addParameter(periodParameter);
     addModulator(lfo).trigger();
     addModulator(sinLfo).trigger();
     centerX = (model.xMax + model.xMin) / 2;
@@ -41,7 +43,7 @@ class TimSpheres extends SCPattern {
     spheres[1].radius = 50;
   }
   
-  public void run(int deltaMs) {
+  public void run(double deltaMs) {
     // Access the core master hue via this method call
     float hv = hueParameter.getValuef();
     float lfoValue = lfo.getValuef();
@@ -53,16 +55,16 @@ class TimSpheres extends SCPattern {
     spheres[0].radius = 100 * hueParameter.getValuef();
     spheres[1].radius = 100 * hueParameter.getValuef();
     
-    for (Point p : model.points) {
+    for (LXPoint p : model.points) {
       float value = 0;
 
-      color c = color(0, 0, 0);      
+      color c = lx.hsb(0, 0, 0);      
       for (Sphere s : spheres) {
         float d = sqrt(pow(p.x - s.x, 2) + pow(p.y - s.y, 2) + pow(p.z - s.z, 2));
         float r = (s.radius); // * (sinLfoValue + 0.5));
         value = max(0, 1 - max(0, d - r) / 10);
         
-        c = blendColor(c, color(((s.hue + lfoValue) % 1) * 360, 100, min(1, value) * 100), ADD);
+        c = blendColor(c, lx.hsb(((s.hue + lfoValue) % 1) * 360, 100, min(1, value) * 100), ADD);
       }
       
       colors[p.index] = c;
@@ -124,8 +126,8 @@ class Vector3 {
     return distanceTo(v.x, v.y, v.z);
   }
   
-  float distanceTo(Point p) {
-    return distanceTo(p.fx, p.fy, p.fz);
+  float distanceTo(LXPoint p) {
+    return distanceTo(p.x, p.y, p.z);
   }
   
   void add(Vector3 other, float multiplier) {
@@ -224,8 +226,8 @@ class TimRaindrops extends SCPattern {
     }
     
     // returns TRUE when this should die
-    boolean age(int ms) {
-      p.add(v, ms / 1000.0);
+    boolean age(double ms) {
+      p.add(v, (float) (ms / 1000.0));
       return this.p.y < (0 - this.radius);
     }
   }
@@ -234,31 +236,31 @@ class TimRaindrops extends SCPattern {
   private float msPerRaindrop = 40;
   private List<Raindrop> raindrops;
   
-  public TimRaindrops(GLucose glucose) {
-    super(glucose);
+  public TimRaindrops(LX lx) {
+    super(lx);
     raindrops = new LinkedList<Raindrop>();
   }
   
-  public void run(int deltaMs) {
+  public void run(double deltaMs) {
     leftoverMs += deltaMs;
     while (leftoverMs > msPerRaindrop) {
       leftoverMs -= msPerRaindrop;
       raindrops.add(new Raindrop());
     }
     
-    for (Point p : model.points) {
+    for (LXPoint p : model.points) {
       color c = 
         blendColor(
-          color(210, 20, (float)Math.max(0, 1 - Math.pow((model.yMax - p.fy) / 10, 2)) * 50),
-          color(220, 60, (float)Math.max(0, 1 - Math.pow((p.fy - model.yMin) / 10, 2)) * 100),
+          lx.hsb(210, 20, (float)Math.max(0, 1 - Math.pow((model.yMax - p.y) / 10, 2)) * 50),
+          lx.hsb(220, 60, (float)Math.max(0, 1 - Math.pow((p.y - model.yMin) / 10, 2)) * 100),
           ADD);
       for (Raindrop raindrop : raindrops) {
-        if (p.fx >= (raindrop.p.x - raindrop.radius) && p.fx <= (raindrop.p.x + raindrop.radius) &&
-            p.fy >= (raindrop.p.y - raindrop.radius) && p.fy <= (raindrop.p.y + raindrop.radius)) {
+        if (p.x >= (raindrop.p.x - raindrop.radius) && p.x <= (raindrop.p.x + raindrop.radius) &&
+            p.y >= (raindrop.p.y - raindrop.radius) && p.y <= (raindrop.p.y + raindrop.radius)) {
           float d = raindrop.p.distanceTo(p) / raindrop.radius;
   //      float value = (float)Math.max(0, 1 - Math.pow(Math.min(0, d - raindrop.radius) / 5, 2)); 
           if (d < 1) {
-            c = blendColor(c, color(raindrop.hue, 80, (float)Math.pow(1 - d, 0.01) * 100), ADD);
+            c = blendColor(c, lx.hsb(raindrop.hue, 80, (float)Math.pow(1 - d, 0.01) * 100), ADD);
           }
         }
       }
@@ -300,16 +302,16 @@ class TimCubes extends SCPattern {
     }
     
     // returns TRUE if this should die
-    boolean age(int ms) {
+    boolean age(double ms) {
       if (!hasPeaked) {
-        value = value + (ms / 1000.0f * ((attackParameter.getValuef() + 0.01) * 5));
+        value = value + (float) (ms / 1000.0f * ((attackParameter.getValuef() + 0.01) * 5));
         if (value >= 1.0) {
           value = 1.0;
           hasPeaked = true;
         }
         return false;
       } else {
-        value = value - (ms / 1000.0f * ((decayParameter.getValuef() + 0.01) * 10));
+        value = value - (float) (ms / 1000.0f * ((decayParameter.getValuef() + 0.01) * 10));
         return value <= 0;
       }
     }
@@ -318,8 +320,8 @@ class TimCubes extends SCPattern {
   private float leftoverMs = 0;
   private List<CubeFlash> flashes;
   
-  public TimCubes(GLucose glucose) {
-    super(glucose);
+  public TimCubes(LX lx) {
+    super(lx);
     addParameter(rateParameter);
     addParameter(attackParameter);
     addParameter(decayParameter);
@@ -329,7 +331,7 @@ class TimCubes extends SCPattern {
     flashes = new LinkedList<CubeFlash>();
   }
   
-  public void run(int deltaMs) {
+  public void run(double deltaMs) {
     leftoverMs += deltaMs;
     float msPerFlash = 1000 / ((rateParameter.getValuef() + .01) * 100);
     while (leftoverMs > msPerFlash) {
@@ -337,14 +339,14 @@ class TimCubes extends SCPattern {
       flashes.add(new CubeFlash());
     }
     
-    for (Point p : model.points) {
+    for (LXPoint p : model.points) {
       colors[p.index] = 0;
     }
     
     for (CubeFlash flash : flashes) {
       float hue = (hueParameter.getValuef() + (hueVarianceParameter.getValuef() * flash.hue)) % 1.0;
-      color c = color(hue * 360, saturationParameter.getValuef() * 100, (flash.value) * 100);
-      for (Point p : flash.c.points) {
+      color c = lx.hsb(hue * 360, saturationParameter.getValuef() * 100, (flash.value) * 100);
+      for (LXPoint p : flash.c.points) {
         colors[p.index] = c;
       }
     }
@@ -395,8 +397,8 @@ class TimPlanes extends SCPattern {
     }
   }
       
-  TimPlanes(GLucose glucose) {
-    super(glucose);
+  TimPlanes(LX lx) {
+    super(lx);
     centerX = (model.xMin + model.xMax) / 2;
     centerY = (model.yMin + model.yMax) / 2;
     centerZ = (model.zMin + model.zMax) / 2;
@@ -416,7 +418,7 @@ class TimPlanes extends SCPattern {
   float prevRamp = 0;
   float[] wobbleSpeeds = { 1.0/8, 1.0/4, 1.0/2, 1.0 };
   
-  public void run(int deltaMs) {
+  public void run(double deltaMs) {
     float ramp = (float)lx.tempo.ramp();
     if (ramp < prevRamp) {
       beat = (beat + 1) % 32;
@@ -456,7 +458,7 @@ class TimPlanes extends SCPattern {
     
     Vector3 normalizedPoint = new Vector3();
 
-    for (Point p : model.points) {
+    for (LXPoint p : model.points) {
       if (random(1.0) < derez) {
         continue;
       }
@@ -464,19 +466,19 @@ class TimPlanes extends SCPattern {
       color c = 0;
       
       for (Plane plane : planes) {
-        normalizedPoint.x = p.fx - plane.center.x;
-        normalizedPoint.y = p.fy - plane.center.y;
-        normalizedPoint.z = p.fz - plane.center.z;
+        normalizedPoint.x = p.x - plane.center.x;
+        normalizedPoint.y = p.y - plane.center.y;
+        normalizedPoint.z = p.z - plane.center.z;
         
         float v = plane.rotation.rotatedY(normalizedPoint);
         float d = abs(v);
         
         final color planeColor;
         if (d <= thickness) {
-          planeColor = color(plane.hue, saturation, 100);
+          planeColor = lx.hsb(plane.hue, saturation, 100);
         } else if (d <= thickness * 2) {    
           float value = 1 - ((d - thickness) / thickness);
-          planeColor = color(plane.hue, saturation, value * 100);
+          planeColor = lx.hsb(plane.hue, saturation, value * 100);
         } else {
           planeColor = 0;
         }
@@ -558,8 +560,8 @@ class TimPinwheels extends SCPattern {
   private final List<Pinwheel> pinwheels;
   private final float[] values;
   
-  TimPinwheels(GLucose glucose) {
-    super(glucose);
+  TimPinwheels(LX lx) {
+    super(lx);
     
     addParameter(horizSpreadParameter);
 //    addParameter(vertSpreadParameter);
@@ -609,7 +611,7 @@ class TimPinwheels extends SCPattern {
   
   private float prevRamp = 0;
   
-  public void run(int deltaMs) {
+  public void run(double deltaMs) {
     float ramp = lx.tempo.rampf();
     float numBeats = (1 + ramp - prevRamp) % 1;
     prevRamp = ramp;
@@ -620,7 +622,7 @@ class TimPinwheels extends SCPattern {
     // 1 -> 180
     float hueSpread = (hueSpreadParameter.getValuef() - 0.5) * 360;
     
-    float fadeAmount = (deltaMs / 1000.0) * pow(sharpnessParameter.getValuef() * 10, 1);
+    float fadeAmount = (float) (deltaMs / 1000.0) * pow(sharpnessParameter.getValuef() * 10, 1);
     
     for (Pinwheel pw : pinwheels) {
       pw.age(numBeats);
@@ -631,25 +633,25 @@ class TimPinwheels extends SCPattern {
     float zSlope = (zSlopeParameter.getValuef() - 0.5) * 2;
     
     int i = -1;
-    for (Point p : model.points) {
+    for (LXPoint p : model.points) {
       ++i;
       
       int value = 0;
       for (Pinwheel pw : pinwheels) {
-        value += (pw.isOnBlade(p.fx, p.fy - p.fz * zSlope) ? 1 : 0);
+        value += (pw.isOnBlade(p.x, p.y - p.z * zSlope) ? 1 : 0);
       }
       if (value == 1) {
         values[i] = 1;
-//        colors[p.index] = color(120, 0, 100);
+//        colors[p.index] = lx.hsb(120, 0, 100);
       } else {
         values[i] = max(0, values[i] - fadeAmount);
         //color c = colors[p.index];
-        //colors[p.index] = color(max(0, hue(c) - 10), min(100, saturation(c) + 10), brightness(c) - 5 );
+        //colors[p.index] = lx.hsb(max(0, lx.h(c) - 10), min(100, lx.s(c) + 10), lx.b(c) - 5 );
       }
       
       if (random(1.0) >= derez) {
         float v = values[i];
-        colors[p.index] = color((360 + hue + pow(v, 2) * hueSpread) % 360, 30 + pow(1 - v, 0.25) * 60, v * 100);
+        colors[p.index] = lx.hsb((360 + hue + pow(v, 2) * hueSpread) % 360, 30 + pow(1 - v, 0.25) * 60, v * 100);
       }      
     }
   }
@@ -663,25 +665,25 @@ class TimPinwheels extends SCPattern {
  * it but there may be useful code here.
  */
 class TimTrace extends SCPattern {
-  private Map<Point, List<Point>> pointToNeighbors;
-  private Map<Point, Strip> pointToStrip;
+  private Map<LXPoint, List<LXPoint>> pointToNeighbors;
+  private Map<LXPoint, Strip> pointToStrip;
   //  private final Map<Strip, List<Strip>> stripToNearbyStrips;
   
   int extraMs;
   
   class MovingPoint {
-    Point currentPoint;
+    LXPoint currentPoint;
     float hue;
     private Strip currentStrip;
     private int currentStripIndex;
     private int direction; // +1 or -1
     
-    MovingPoint(Point p) {
+    MovingPoint(LXPoint p) {
       this.setPointOnNewStrip(p);
       hue = random(360);
     }
     
-    private void setPointOnNewStrip(Point p) {
+    private void setPointOnNewStrip(LXPoint p) {
       this.currentPoint = p;
       this.currentStrip = pointToStrip.get(p);
       for (int i = 0; i < this.currentStrip.points.size(); ++i) {
@@ -703,9 +705,9 @@ class TimTrace extends SCPattern {
     }
     
     void step() {
-      List<Point> neighborsOnOtherStrips = pointToNeighbors.get(this.currentPoint);
+      List<LXPoint> neighborsOnOtherStrips = pointToNeighbors.get(this.currentPoint);
 
-      Point nextPointOnCurrentStrip = null;      
+      LXPoint nextPointOnCurrentStrip = null;      
       this.currentStripIndex += this.direction;
       if (this.currentStripIndex >= 0 && this.currentStripIndex < this.currentStrip.points.size()) {
         nextPointOnCurrentStrip = this.currentStrip.points.get(this.currentStripIndex);
@@ -725,8 +727,8 @@ class TimTrace extends SCPattern {
   
   List<MovingPoint> movingPoints;
   
-  TimTrace(GLucose glucose) {
-    super(glucose);
+  TimTrace(LX lx) {
+    super(lx);
     
     extraMs = 0;
     
@@ -745,8 +747,8 @@ class TimTrace extends SCPattern {
     Map<Strip, Vector3> stripToCenter = new HashMap();
     for (Strip s : model.strips) {
       Vector3 v = new Vector3();
-      for (Point p : s.points) {
-        v.add(p.fx, p.fy, p.fz);
+      for (LXPoint p : s.points) {
+        v.add(p.x, p.y, p.z);
       }
       v.divide(s.points.size());
       stripToCenter.put(s, v);
@@ -770,24 +772,24 @@ class TimTrace extends SCPattern {
     return stripToNeighbors;
   }
   
-  private Map<Point, List<Point>> buildPointToNeighborsMap() {
-    Map<Point, List<Point>> m = new HashMap();
+  private Map<LXPoint, List<LXPoint>> buildPointToNeighborsMap() {
+    Map<LXPoint, List<LXPoint>> m = new HashMap();
     Map<Strip, List<Strip>> stripToNearbyStrips = this.buildStripToNearbyStripsMap();
     
     for (Strip s : model.strips) {
       List<Strip> nearbyStrips = stripToNearbyStrips.get(s);
       
-      for (Point p : s.points) {
-        Vector3 v = new Vector3(p.fx, p.fy, p.fz);
+      for (LXPoint p : s.points) {
+        Vector3 v = new Vector3(p.x, p.y, p.z);
         
-        List<Point> neighbors = new ArrayList();
+        List<LXPoint> neighbors = new ArrayList();
         
         for (Strip nearbyStrip : nearbyStrips) {
-          Point closestPoint = null;
+          LXPoint closestPoint = null;
           float closestPointDistance = 100000;
           
-          for (Point nsp : nearbyStrip.points) {
-            float distance = v.distanceTo(nsp.fx, nsp.fy, nsp.fz);
+          for (LXPoint nsp : nearbyStrip.points) {
+            float distance = v.distanceTo(nsp.x, nsp.y, nsp.z);
             if (closestPoint == null || distance < closestPointDistance) {
               closestPoint = nsp;
               closestPointDistance = distance;
@@ -806,25 +808,94 @@ class TimTrace extends SCPattern {
     return m;
   }
   
-  private Map<Point, Strip> buildPointToStripMap() {
-    Map<Point, Strip> m = new HashMap();
+  private Map<LXPoint, Strip> buildPointToStripMap() {
+    Map<LXPoint, Strip> m = new HashMap();
     for (Strip s : model.strips) {
-      for (Point p : s.points) {
+      for (LXPoint p : s.points) {
         m.put(p, s);
       }
     }
     return m;
   }
   
-  public void run(int deltaMs) {
-    for (Point p : model.points) {
+  public void run(double deltaMs) {
+    for (LXPoint p : model.points) {
       color c = colors[p.index];
-      colors[p.index] = color(hue(c), saturation(c), brightness(c) - 3);
+      colors[p.index] = lx.hsb(lx.h(c), lx.s(c), lx.b(c) - 3);
     }
     
     for (MovingPoint mp : movingPoints) {
       mp.step();
-      colors[mp.currentPoint.index] = blendColor(colors[mp.currentPoint.index], color(mp.hue, 10, 100), ADD);
+      colors[mp.currentPoint.index] = blendColor(colors[mp.currentPoint.index], lx.hsb(mp.hue, 10, 100), ADD);
     }
   }
 }
+
+class TimMetronome extends SCPattern {
+  private BasicParameter clickyParameter = new BasicParameter("CLICK", 0, 0, 10.0);
+  private BasicParameter derezParameter = new BasicParameter("DREZ", 0.5, 0, 1.0);
+  private BasicParameter driftParameter = new BasicParameter("DRIFT", 0, 0, 1.0);
+  private BasicParameter fadeParameter = new BasicParameter("FADE", 0.05, 0, 0.2);
+  private float modelWidth;
+  private int beatNum;
+  private float prevTempoRamp;
+  private LXProjection projection;
+  private float[] values;
+  private float[] hues;
+  
+  TimMetronome(LX lx) {
+    super(lx);
+    addParameter(clickyParameter);
+    addParameter(derezParameter);
+    addParameter(driftParameter);
+    addParameter(fadeParameter);
+    modelWidth = model.xMax - model.xMin;
+    projection = new LXProjection(model);
+    beatNum = 0;
+    prevTempoRamp = 0;
+    values = new float[model.points.size()];
+    hues = new float[model.points.size()];
+  }
+  
+  public void run(double deltaMs) {
+    float tempoRamp = lx.tempo.rampf();
+    if (tempoRamp < prevTempoRamp) {
+      beatNum = (beatNum + 1) % 1000;
+    }
+    prevTempoRamp = tempoRamp;
+    
+    float phase = beatNum + pow(tempoRamp, 1.0 + clickyParameter.getValuef());
+    
+    projection.reset();
+    projection.translateCenter(model.xMin, model.yMin, model.cz);
+    projection.rotate(phase * 0.5 * PI, 0, 0, 1);
+    
+    projection.translate(driftParameter.getValuef() * tempoRamp * modelWidth * 0.5, 0, 0);
+    
+    float derezCutoff = derezParameter.getValuef();
+    
+    float fadeMultiplier = (1.0 - fadeParameter.getValuef());
+    
+    float armRadius = modelWidth * 0.1;
+    for (LXVector p : projection) {
+      boolean onArm = false;
+      if (abs(p.x) < armRadius) {
+        onArm = (p.y > 0) || (sqrt(pow(p.x, 2) + pow(p.y, 2)) < armRadius);
+      }
+      if (onArm) {
+        values[p.index] = 1.0;
+        hues[p.index] = (floor(phase / 4) * 90) % 360;
+      } else {
+        values[p.index] *= fadeMultiplier;
+      }
+      
+      float saturation = pow(1 - values[p.index], 0.5) * 0.7 + 0.3;
+      float brightness = values[p.index];
+      
+      if (random(1.0) > derezCutoff) {
+        colors[p.index] = lx.hsb(hues[p.index], saturation * 100, brightness * 100);
+      }
+    }
+  }
+}
+