_Internals.pde

   1 /**
   2  *     DOUBLE BLACK DIAMOND        DOUBLE BLACK DIAMOND
   3  *
   4  *         //\\   //\\                 //\\   //\\
   5  *        ///\\\ ///\\\               ///\\\ ///\\\
   6  *        \\\/// \\\///               \\\/// \\\///
   7  *         \\//   \\//                 \\//   \\//
   8  *
   9  *        EXPERTS ONLY!!              EXPERTS ONLY!!
  10  *
  11  * If you are an artist, you may ignore this file! It just sets
  12  * up the framework to run the patterns. Should not need modification
  13  * for general animation work.
  14  */
  15
  16 import glucose.*;
  17 import glucose.control.*;
  18 import glucose.effect.*;
  19 import glucose.model.*;
  20 import glucose.pattern.*;
  21 import glucose.transform.*;
  22 import glucose.transition.*;
  23 import heronarts.lx.*;
  24 import heronarts.lx.control.*;
  25 import heronarts.lx.effect.*;
  26 import heronarts.lx.modulator.*;
  27 import heronarts.lx.pattern.*;
  28 import heronarts.lx.transition.*;
  29 import ddf.minim.*;
  30 import ddf.minim.analysis.*;
  31 import processing.opengl.*;
  32 import rwmidi.*;
  33
  34 final int VIEWPORT_WIDTH = 900;
  35 final int VIEWPORT_HEIGHT = 700;
  36
  37 // The trailer is measured from the outside of the black metal (but not including the higher welded part on the front)
  38 final float TRAILER_WIDTH = 240;
  39 final float TRAILER_DEPTH = 97;
  40 final float TRAILER_HEIGHT = 33;
  41
  42 int targetFramerate = 60;
  43
  44 int startMillis, lastMillis;
  45 GLucose glucose;
  46 HeronLX lx;
  47 MappingTool mappingTool;
  48 LXPattern[] patterns;
  49 LXTransition[] transitions;
  50 LXEffect[] effects;
  51 OverlayUI ui;
  52 ControlUI controlUI;
  53 MappingUI mappingUI;
  54 PandaDriver[] pandaBoards;
  55 boolean mappingMode = false;
  56 boolean debugMode = false;
  57 DebugUI debugUI;
  58
  59 // Camera variables
  60 float eyeR, eyeA, eyeX, eyeY, eyeZ, midX, midY, midZ;
  61
  62 void setup() {
  63   startMillis = lastMillis = millis();
  64
  65   // Initialize the Processing graphics environment
  66   size(VIEWPORT_WIDTH, VIEWPORT_HEIGHT, OPENGL);
  67   frameRate(targetFramerate);
  68   noSmooth();
  69   // hint(ENABLE_OPENGL_4X_SMOOTH); // no discernable improvement?
  70   logTime("Created viewport");
  71
  72   // Create the GLucose engine to run the cubes
  73   glucose = new GLucose(this, buildModel());
  74   lx = glucose.lx;
  75   lx.enableKeyboardTempo();
  76   logTime("Built GLucose engine");
  77
  78   // Set the patterns
  79   glucose.lx.setPatterns(patterns = patterns(glucose));
  80   logTime("Built patterns");
  81   glucose.lx.addEffects(effects = effects(glucose));
  82   logTime("Built effects");
  83   glucose.setTransitions(transitions = transitions(glucose));
  84   logTime("Built transitions");
  85
  86   // Build output driver
  87   PandaMapping[] pandaMappings = buildPandaList();
  88   pandaBoards = new PandaDriver[pandaMappings.length];
  89   int pbi = 0;
  90   for (PandaMapping pm : pandaMappings) {
  91     pandaBoards[pbi++] = new PandaDriver(pm.ip, glucose.model, pm);
  92   }
  93   mappingTool = new MappingTool(glucose, pandaMappings);
  94   logTime("Built PandaDriver");
  95
  96   // Build overlay UI
  97   ui = controlUI = new ControlUI();
  98   mappingUI = new MappingUI(mappingTool);
  99   debugUI = new DebugUI(pandaMappings);
 100   logTime("Built overlay UI");
 101
 102   // MIDI devices
 103   for (MidiInputDevice d : RWMidi.getInputDevices()) {
 104     d.createInput(this);
 105   }
 106   SCMidiDevices.initializeStandardDevices(glucose);
 107   logTime("Setup MIDI devices");
 108
 109   // Setup camera
 110   midX = TRAILER_WIDTH/2. + 20;
 111   midY = glucose.model.yMax/2;
 112   midZ = TRAILER_DEPTH/2.;
 113   eyeR = -290;
 114   eyeA = .15;
 115   eyeY = midY + 20;
 116   eyeX = midX + eyeR*sin(eyeA);
 117   eyeZ = midZ + eyeR*cos(eyeA);
 118   addMouseWheelListener(new java.awt.event.MouseWheelListener() {
 119     public void mouseWheelMoved(java.awt.event.MouseWheelEvent mwe) {
 120       mouseWheel(mwe.getWheelRotation());
 121   }});
 122
 123   println("Total setup: " + (millis() - startMillis) + "ms");
 124   println("Hit the 'p' key to toggle Panda Board output");
 125 }
 126
 127 boolean[] noteState = new boolean[16];
 128
 129 void controllerChangeReceived(rwmidi.Controller cc) {
 130   if (debugMode) {
 131     println("CC: " + cc.toString());
 132   }
 133   //println(cc.getInput().getName());
 134   int c = cc.getCC();
 135   if(c==1){
 136     for(int i=0; i<16; i++){
 137       if(noteState[i] && i<8)  { LXParameter p = glucose.patternKnobs.get(i); p.setValue(cc.getValue()/127.0); }
 138       else if(noteState[i] && i<16) { try { LXParameter p = gparams.get(i-8); p.setValue(cc.getValue()/127.0); } catch(Exception e) {} }
 139     }
 140   }
 141   if(c==2){
 142     for(int i=0; i<16; i++){
 143       //sif(noteState[i] && i<8)  { println( gplay.Sliders ); }
 144       //else if(noteState[i] && i<16) { try { LXParameter p = gparams.get(i-8); p.setValue(cc.getValue()/127.0); } catch(Exception e) {} }
 145     }
 146   }
 147
 148
 149   //if(c>=16 || c<16+8){
 150   //    LXParameter p = gparams.get(c-16);
 151   //    p.setValue(c/127.0);
 152   //}
 153 }
 154
 155
 156 void noteOnReceived(Note note) {
 157   if (debugMode) {
 158     println("Note On: " + note.toString());
 159   }
 160   int pitch = note.getPitch();
 161   if(pitch>=36 && pitch <36+16){
 162     noteState[pitch-36]=true;
 163   }
 164 }
 165
 166 void noteOffReceived(Note note) {
 167   if (debugMode) {
 168     println("Note Off: " + note.toString());
 169   }
 170   int pitch = note.getPitch();
 171   if(pitch>=36 && pitch <36+16){
 172     noteState[pitch-36]=false;
 173   }
 174 }
 175
 176
 177 void logTime(String evt) {
 178   int now = millis();
 179   println(evt + ": " + (now - lastMillis) + "ms");
 180   lastMillis = now;
 181 }
 182
 183 void draw() {
 184   // Draws the simulation and the 2D UI overlay
 185   background(40);
 186   color[] colors = glucose.getColors();
 187   if (debugMode) {
 188     debugUI.maskColors(colors);
 189   }
 190
 191   camera(
 192     eyeX, eyeY, eyeZ,
 193     midX, midY, midZ,
 194     0, -1, 0
 195   );
 196
 197   noStroke();
 198   fill(#141414);
 199   drawBox(0, -TRAILER_HEIGHT, 0, 0, 0, 0, TRAILER_WIDTH, TRAILER_HEIGHT, TRAILER_DEPTH, TRAILER_HEIGHT/2.);
 200   fill(#070707);
 201   stroke(#222222);
 202   beginShape();
 203   vertex(0, 0, 0);
 204   vertex(TRAILER_WIDTH, 0, 0);
 205   vertex(TRAILER_WIDTH, 0, TRAILER_DEPTH);
 206   vertex(0, 0, TRAILER_DEPTH);
 207   endShape();
 208
 209   noStroke();
 210   drawBassBox(glucose.model.bassBox);
 211   for (Speaker s : glucose.model.speakers) {
 212     drawSpeaker(s);
 213   }
 214   for (Cube c : glucose.model.cubes) {
 215     drawCube(c);
 216   }
 217
 218   noFill();
 219   strokeWeight(2);
 220   beginShape(POINTS);
 221   for (Point p : glucose.model.points) {
 222     stroke(colors[p.index]);
 223     vertex(p.fx, p.fy, p.fz);
 224   }
 225   endShape();
 226
 227   // 2D Overlay
 228   camera();
 229   javax.media.opengl.GL gl = ((PGraphicsOpenGL)g).beginGL();
 230   gl.glClear(javax.media.opengl.GL.GL_DEPTH_BUFFER_BIT);
 231   ((PGraphicsOpenGL)g).endGL();
 232   strokeWeight(1);
 233   drawUI();
 234
 235   if (debugMode) {
 236     debugUI.draw();
 237   }
 238
 239   // Gamma correction here. Apply a cubic to the brightness
 240   // for better representation of dynamic range
 241   for (int i = 0; i < colors.length; ++i) {
 242     float b = brightness(colors[i]) / 100.f;
 243     colors[i] = color(
 244       hue(colors[i]),
 245       saturation(colors[i]),
 246       (b*b*b) * 100.
 247     );
 248   }
 249
 250   // TODO(mcslee): move into GLucose engine
 251   for (PandaDriver p : pandaBoards) {
 252     p.sendNow(colors);
 253   }
 254 }
 255
 256 void drawBassBox(BassBox b) {
 257   /*
 258   float in = .15;
 259
 260   noStroke();
 261   fill(#191919);
 262   pushMatrix();
 263   translate(b.x + BassBox.EDGE_WIDTH/2., b.y + BassBox.EDGE_HEIGHT/2, b.z + BassBox.EDGE_DEPTH/2.);
 264   box(BassBox.EDGE_WIDTH-20*in, BassBox.EDGE_HEIGHT-20*in, BassBox.EDGE_DEPTH-20*in);
 265   popMatrix();
 266
 267   noStroke();
 268   fill(#393939);
 269   drawBox(b.x+in, b.y+in, b.z+in, 0, 0, 0, BassBox.EDGE_WIDTH-in*2, BassBox.EDGE_HEIGHT-in*2, BassBox.EDGE_DEPTH-in*2, Cube.CHANNEL_WIDTH-in);
 270
 271   pushMatrix();
 272   translate(b.x+(Cube.CHANNEL_WIDTH-in)/2., b.y + BassBox.EDGE_HEIGHT-in, b.z + BassBox.EDGE_DEPTH/2.);
 273   float lastOffset = 0;
 274   for (float offset : BoothFloor.STRIP_OFFSETS) {
 275     translate(offset - lastOffset, 0, 0);
 276     box(Cube.CHANNEL_WIDTH-in, 0, BassBox.EDGE_DEPTH - 2*in);
 277     lastOffset = offset;
 278   }
 279   popMatrix();
 280
 281   pushMatrix();
 282   translate(b.x + (Cube.CHANNEL_WIDTH-in)/2., b.y + BassBox.EDGE_HEIGHT/2., b.z + in);
 283   for (int j = 0; j < 2; ++j) {
 284     pushMatrix();
 285     for (int i = 0; i < BassBox.NUM_FRONT_STRUTS; ++i) {
 286       translate(BassBox.FRONT_STRUT_SPACING, 0, 0);
 287       box(Cube.CHANNEL_WIDTH-in, BassBox.EDGE_HEIGHT - in*2, 0);
 288     }
 289     popMatrix();
 290     translate(0, 0, BassBox.EDGE_DEPTH - 2*in);
 291   }
 292   popMatrix();
 293
 294   pushMatrix();
 295   translate(b.x + in, b.y + BassBox.EDGE_HEIGHT/2., b.z + BassBox.SIDE_STRUT_SPACING + (Cube.CHANNEL_WIDTH-in)/2.);
 296   box(0, BassBox.EDGE_HEIGHT - in*2, Cube.CHANNEL_WIDTH-in);
 297   translate(BassBox.EDGE_WIDTH-2*in, 0, 0);
 298   box(0, BassBox.EDGE_HEIGHT - in*2, Cube.CHANNEL_WIDTH-in);
 299   popMatrix();*/
 300
 301 }
 302
 303 void drawCube(Cube c) {
 304   float in = .15;
 305   noStroke();
 306   fill(#393939);
 307   drawBox(c.x+in, c.y+in, c.z+in, c.rx, c.ry, c.rz, Cube.EDGE_WIDTH-in*2, Cube.EDGE_HEIGHT-in*2, Cube.EDGE_WIDTH-in*2, Cube.CHANNEL_WIDTH-in);
 308 }
 309
 310 void drawSpeaker(Speaker s) {
 311   float in = .15;
 312
 313   noStroke();
 314   fill(#191919);
 315   pushMatrix();
 316   translate(s.x, s.y, s.z);
 317   rotate(s.ry / 180. * PI, 0, -1, 0);
 318   translate(Speaker.EDGE_WIDTH/2., Speaker.EDGE_HEIGHT/2., Speaker.EDGE_DEPTH/2.);
 319   box(Speaker.EDGE_WIDTH-20*in, Speaker.EDGE_HEIGHT-20*in, Speaker.EDGE_DEPTH-20*in);
 320   translate(0, Speaker.EDGE_HEIGHT/2. + Speaker.EDGE_HEIGHT*.8/2, 0);
 321
 322   fill(#222222);
 323   box(Speaker.EDGE_WIDTH*.6, Speaker.EDGE_HEIGHT*.8, Speaker.EDGE_DEPTH*.75);
 324   popMatrix();
 325
 326   noStroke();
 327   fill(#393939);
 328   drawBox(s.x+in, s.y+in, s.z+in, 0, s.ry, 0, Speaker.EDGE_WIDTH-in*2, Speaker.EDGE_HEIGHT-in*2, Speaker.EDGE_DEPTH-in*2, Cube.CHANNEL_WIDTH-in);
 329 }
 330
 331
 332 void drawBox(float x, float y, float z, float rx, float ry, float rz, float xd, float yd, float zd, float sw) {
 333   pushMatrix();
 334   translate(x, y, z);
 335   rotate(rx / 180. * PI, -1, 0, 0);
 336   rotate(ry / 180. * PI, 0, -1, 0);
 337   rotate(rz / 180. * PI, 0, 0, -1);
 338   for (int i = 0; i < 4; ++i) {
 339     float wid = (i % 2 == 0) ? xd : zd;
 340
 341     beginShape();
 342     vertex(0, 0);
 343     vertex(wid, 0);
 344     vertex(wid, yd);
 345     vertex(wid - sw, yd);
 346     vertex(wid - sw, sw);
 347     vertex(0, sw);
 348     endShape();
 349     beginShape();
 350     vertex(0, sw);
 351     vertex(0, yd);
 352     vertex(wid - sw, yd);
 353     vertex(wid - sw, yd - sw);
 354     vertex(sw, yd - sw);
 355     vertex(sw, sw);
 356     endShape();
 357
 358     translate(wid, 0, 0);
 359     rotate(HALF_PI, 0, -1, 0);
 360   }
 361   popMatrix();
 362 }
 363
 364 void drawUI() {
 365   if (uiOn) {
 366     ui.draw();
 367   } else {
 368     ui.drawHelpTip();
 369   }
 370   ui.drawFPS();
 371   ui.drawDanText();
 372 }
 373
 374 boolean uiOn = true;
 375 int restoreToIndex = -1;
 376
 377 boolean doDual = false;
 378 void keyPressed() {
 379   if (mappingMode) {
 380     mappingTool.keyPressed();
 381   }
 382   switch (key) {
 383     case 'w':
 384        doDual = !doDual;
 385        break;
 386     case '-':
 387     case '_':
 388       frameRate(--targetFramerate);
 389       break;
 390     case '=':
 391     case '+':
 392       frameRate(++targetFramerate);
 393       break;
 394     case 'd':
 395       debugMode = !debugMode;
 396       println("Debug output: " + (debugMode ? "ON" : "OFF"));
 397       break;
 398     case 'm':
 399       mappingMode = !mappingMode;
 400       if (mappingMode) {
 401         LXPattern pattern = lx.getPattern();
 402         for (int i = 0; i < patterns.length; ++i) {
 403           if (pattern == patterns[i]) {
 404             restoreToIndex = i;
 405             break;
 406           }
 407         }
 408         ui = mappingUI;
 409         lx.setPatterns(new LXPattern[] { mappingTool });
 410       } else {
 411         ui = controlUI;
 412         lx.setPatterns(patterns);
 413         lx.goIndex(restoreToIndex);
 414       }
 415       break;
 416     case 'p':
 417       for (PandaDriver p : pandaBoards) {
 418         p.toggle();
 419       }
 420       break;
 421     case 'u':
 422       uiOn = !uiOn;
 423       break;
 424   }
 425 }
 426
 427 int mx, my;
 428 void mousePressed() {
 429   ui.mousePressed();
 430   if (mouseX < ui.leftPos) {
 431     if (debugMode) {
 432       debugUI.mousePressed();
 433     }
 434     mx = mouseX;
 435     my = mouseY;
 436   }
 437 }
 438
 439 void mouseDragged() {
 440   if (mouseX > ui.leftPos) {
 441     ui.mouseDragged();
 442   } else {
 443     int dx = mouseX - mx;
 444     int dy = mouseY - my;
 445     mx = mouseX;
 446     my = mouseY;
 447     eyeA += dx*.003;
 448     eyeX = midX + eyeR*sin(eyeA);
 449     eyeZ = midZ + eyeR*cos(eyeA);
 450     eyeY += dy;
 451   }
 452 }
 453
 454 void mouseReleased() {
 455   ui.mouseReleased();
 456 }
 457
 458 void mouseWheel(int delta) {
 459   if (mouseX > ui.leftPos) {
 460     ui.mouseWheel(delta);
 461   } else {
 462     eyeR = constrain(eyeR - delta, -500, -80);
 463     eyeX = midX + eyeR*sin(eyeA);
 464     eyeZ = midZ + eyeR*cos(eyeA);
 465   }
 466 }