_Internals.pde

   1 /**
   2  *     DOUBLE BLACK DIAMOND        DOUBLE BLACK DIAMOND
   3  *
   4  *         //\\   //\\                 //\\   //\\
   5  *        ///\\\ ///\\\               ///\\\ ///\\\
   6  *        \\\/// \\\///               \\\/// \\\///
   7  *         \\//   \\//                 \\//   \\//H
   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 import java.lang.reflect.*;
  34
  35 final int VIEWPORT_WIDTH = 900;
  36 final int VIEWPORT_HEIGHT = 700;
  37
  38 // The trailer is measured from the outside of the black metal (but not including the higher welded part on the front)
  39 final float TRAILER_WIDTH = 240;
  40 final float TRAILER_DEPTH = 97;
  41 final float TRAILER_HEIGHT = 33;
  42
  43 final int MaxCubeHeight = 5;
  44 final int NumBackTowers = 11;
  45
  46 int targetFramerate = 60;
  47 int startMillis, lastMillis;
  48
  49 // Core engine variables
  50 GLucose glucose;
  51 LX lx;
  52 LXPattern[] patterns;
  53 Effects effects;
  54 MappingTool mappingTool;
  55 PandaDriver[] pandaBoards;
  56 PresetManager presetManager;
  57 MidiEngine midiEngine;
  58
  59 // Display configuration mode
  60 boolean mappingMode = false;
  61 boolean debugMode = false;
  62 DebugUI debugUI;
  63 boolean uiOn = true;
  64 boolean simulationOn = true;
  65 boolean diagnosticsOn = false;
  66 LXPattern restoreToPattern = null;
  67 PImage logo;
  68 float[] hsb = new float[3];
  69
  70 // Handles to UI objects
  71 UIContext[] overlays;
  72 UIPatternDeck uiPatternA;
  73 UICrossfader uiCrossfader;
  74 UIMidi uiMidi;
  75 UIMapping uiMapping;
  76 UIDebugText uiDebugText;
  77 UISpeed uiSpeed;
  78
  79 // Camera variables
  80 float eyeR, eyeA, eyeX, eyeY, eyeZ, midX, midY, midZ;
  81
  82 /**
  83  * Engine construction and initialization.
  84  */
  85
  86 LXTransition _transition(GLucose glucose) {
  87   return new DissolveTransition(glucose.lx).setDuration(1000);
  88 }
  89
  90 LXPattern[] _leftPatterns(GLucose glucose) {
  91   LXPattern[] patterns = patterns(glucose);
  92   for (LXPattern p : patterns) {
  93     p.setTransition(_transition(glucose));
  94   }
  95   return patterns;
  96 }
  97
  98 LXPattern[] _rightPatterns(GLucose glucose) {
  99   LXPattern[] patterns = _leftPatterns(glucose);
 100   LXPattern[] rightPatterns = new LXPattern[patterns.length+1];
 101   int i = 0;
 102   rightPatterns[i++] = new BlankPattern(glucose).setTransition(_transition(glucose));
 103   for (LXPattern p : patterns) {
 104     rightPatterns[i++] = p;
 105   }
 106   return rightPatterns;
 107 }
 108
 109 LXEffect[] _effectsArray(Effects effects) {
 110   List<LXEffect> effectList = new ArrayList<LXEffect>();
 111   for (Field f : effects.getClass().getDeclaredFields()) {
 112     try {
 113       Object val = f.get(effects);
 114       if (val instanceof LXEffect) {
 115         effectList.add((LXEffect)val);
 116       }
 117     } catch (IllegalAccessException iax) {}
 118   }
 119   return effectList.toArray(new LXEffect[]{});
 120 }
 121
 122 void logTime(String evt) {
 123   int now = millis();
 124   println(evt + ": " + (now - lastMillis) + "ms");
 125   lastMillis = now;
 126 }
 127
 128 void setup() {
 129   startMillis = lastMillis = millis();
 130
 131   // Initialize the Processing graphics environment
 132   size(VIEWPORT_WIDTH, VIEWPORT_HEIGHT, OPENGL);
 133   frameRate(targetFramerate);
 134   noSmooth();
 135   // hint(ENABLE_OPENGL_4X_SMOOTH); // no discernable improvement?
 136   logTime("Created viewport");
 137
 138   // Create the GLucose engine to run the cubes
 139   glucose = new GLucose(this, buildModel());
 140   lx = glucose.lx;
 141   lx.enableKeyboardTempo();
 142   logTime("Built GLucose engine");
 143
 144   // Set the patterns
 145   LXEngine engine = lx.engine;
 146   engine.setPatterns(patterns = _leftPatterns(glucose));
 147   engine.addDeck(_rightPatterns(glucose));
 148   logTime("Built patterns");
 149   glucose.setTransitions(transitions(glucose));
 150   logTime("Built transitions");
 151   glucose.lx.addEffects(_effectsArray(effects = new Effects()));
 152   logTime("Built effects");
 153
 154   // Preset manager
 155   presetManager = new PresetManager();
 156   logTime("Loaded presets");
 157
 158   // MIDI devices
 159   midiEngine = new MidiEngine();
 160   logTime("Setup MIDI devices");
 161
 162   // Build output driver
 163   PandaMapping[] pandaMappings = buildPandaList();
 164   pandaBoards = new PandaDriver[pandaMappings.length];
 165   int pbi = 0;
 166   for (PandaMapping pm : pandaMappings) {
 167     pandaBoards[pbi++] = new PandaDriver(pm.ip, glucose.model, pm);
 168   }
 169   mappingTool = new MappingTool(glucose, pandaMappings);
 170   logTime("Built PandaDriver");
 171
 172   // Build overlay UI
 173   debugUI = new DebugUI(pandaMappings);
 174   overlays = new UIContext[] {
 175     uiPatternA = new UIPatternDeck(lx.engine.getDeck(GLucose.LEFT_DECK), "PATTERN A", 4, 4, 140, 324),
 176     new UIBlendMode(4, 332, 140, 86),
 177     new UIEffects(4, 422, 140, 144),
 178     new UITempo(4, 570, 140, 50),
 179     uiSpeed = new UISpeed(4, 624, 140, 50),
 180
 181     new UIPatternDeck(lx.engine.getDeck(GLucose.RIGHT_DECK), "PATTERN B", width-144, 4, 140, 324),
 182     uiMidi = new UIMidi(midiEngine, width-144, 332, 140, 158),
 183     new UIOutput(width-144, 494, 140, 106),
 184
 185     uiCrossfader = new UICrossfader(width/2-90, height-90, 180, 86),
 186
 187     uiDebugText = new UIDebugText(148, height-138, width-304, 44),
 188     uiMapping = new UIMapping(mappingTool, 4, 4, 140, 324),
 189   };
 190   uiMapping.setVisible(false);
 191   logTime("Built overlay UI");
 192
 193   // Load logo image
 194   logo = loadImage("data/logo.png");
 195
 196   // Setup camera
 197   midX = TRAILER_WIDTH/2.;
 198   midY = glucose.model.yMax/2;
 199   midZ = TRAILER_DEPTH/2.;
 200   eyeR = -290;
 201   eyeA = .15;
 202   eyeY = midY + 70;
 203   eyeX = midX + eyeR*sin(eyeA);
 204   eyeZ = midZ + eyeR*cos(eyeA);
 205
 206   // Add mouse scrolling event support
 207   addMouseWheelListener(new java.awt.event.MouseWheelListener() {
 208     public void mouseWheelMoved(java.awt.event.MouseWheelEvent mwe) {
 209       mouseWheel(mwe.getWheelRotation());
 210   }});
 211
 212   println("Total setup: " + (millis() - startMillis) + "ms");
 213   println("Hit the 'p' key to toggle Panda Board output");
 214 }
 215
 216 /**
 217  * Core render loop and drawing functionality.
 218  */
 219 void draw() {
 220   long drawStart = System.nanoTime();
 221
 222   // Draws the simulation and the 2D UI overlay
 223   background(40);
 224
 225   color[] simulationColors;
 226   color[] sendColors;
 227   simulationColors = sendColors = glucose.getColors();
 228   String displayMode = uiCrossfader.getDisplayMode();
 229   if (displayMode == "A") {
 230     simulationColors = lx.engine.getDeck(GLucose.LEFT_DECK).getColors();
 231   } else if (displayMode == "B") {
 232     simulationColors = lx.engine.getDeck(GLucose.RIGHT_DECK).getColors();
 233   }
 234   if (debugMode) {
 235     debugUI.maskColors(simulationColors);
 236     debugUI.maskColors(sendColors);
 237   }
 238
 239   long simulationStart = System.nanoTime();
 240   if (simulationOn) {
 241     drawSimulation(simulationColors);
 242   }
 243   long simulationNanos = System.nanoTime() - simulationStart;
 244
 245   // 2D Overlay UI
 246   long uiStart = System.nanoTime();
 247   drawUI();
 248   long uiNanos = System.nanoTime() - uiStart;
 249
 250   long gammaStart = System.nanoTime();
 251   // Gamma correction here. Apply a cubic to the brightness
 252   // for better representation of dynamic range
 253   for (int i = 0; i < sendColors.length; ++i) {
 254     lx.RGBtoHSB(sendColors[i], hsb);
 255     float b = hsb[2];
 256     sendColors[i] = lx.hsb(360.*hsb[0], 100.*hsb[1], 100.*(b*b*b));
 257   }
 258   long gammaNanos = System.nanoTime() - gammaStart;
 259
 260   long sendStart = System.nanoTime();
 261   for (PandaDriver p : pandaBoards) {
 262     p.send(sendColors);
 263   }
 264   long sendNanos = System.nanoTime() - sendStart;
 265
 266   long drawNanos = System.nanoTime() - drawStart;
 267
 268   if (diagnosticsOn) {
 269     drawDiagnostics(drawNanos, simulationNanos, uiNanos, gammaNanos, sendNanos);
 270   }
 271 }
 272
 273 void drawDiagnostics(long drawNanos, long simulationNanos, long uiNanos, long gammaNanos, long sendNanos) {
 274   float ws = 4 / 1000000.;
 275   int thirtyfps = 1000000000 / 30;
 276   int sixtyfps = 1000000000 / 60;
 277   int x = width - 138;
 278   int y = height - 14;
 279   int h = 10;
 280   noFill();
 281   stroke(#999999);
 282   rect(x, y, thirtyfps * ws, h);
 283   noStroke();
 284   int xp = x;
 285   float hv = 0;
 286   for (long val : new long[] {lx.timer.drawNanos, simulationNanos, uiNanos, gammaNanos, sendNanos }) {
 287     fill(lx.hsb(hv % 360, 100, 80));
 288     rect(xp, y, val * ws, h-1);
 289     hv += 140;
 290     xp += val * ws;
 291   }
 292   noFill();
 293   stroke(#333333);
 294   line(x+sixtyfps*ws, y+1, x+sixtyfps*ws, y+h-1);
 295
 296   y = y - 14;
 297   xp = x;
 298   float tw = thirtyfps * ws;
 299   noFill();
 300   stroke(#999999);
 301   rect(x, y, tw, h);
 302   noStroke();
 303   for (long val : new long[] {
 304     lx.engine.timer.deckNanos,
 305     lx.engine.timer.fxNanos}) {
 306     float amt = val / (float) lx.timer.drawNanos;
 307     fill(lx.hsb(hv % 360, 100, 80));
 308     rect(xp, y, amt * tw, h-1);
 309     hv += 140;
 310     xp += amt * tw;
 311   }
 312 }
 313
 314 void drawSimulation(color[] simulationColors) {
 315     camera(
 316     eyeX, eyeY, eyeZ,
 317     midX, midY, midZ,
 318     0, -1, 0
 319   );
 320
 321   translate(0, 40, 0);
 322
 323   noStroke();
 324   fill(#141414);
 325   drawBox(0, -TRAILER_HEIGHT, 0, 0, 0, 0, TRAILER_WIDTH, TRAILER_HEIGHT, TRAILER_DEPTH, TRAILER_HEIGHT/2.);
 326   fill(#070707);
 327   stroke(#222222);
 328   beginShape();
 329   vertex(0, 0, 0);
 330   vertex(TRAILER_WIDTH, 0, 0);
 331   vertex(TRAILER_WIDTH, 0, TRAILER_DEPTH);
 332   vertex(0, 0, TRAILER_DEPTH);
 333   endShape();
 334
 335   // Draw the logo on the front of platform
 336   pushMatrix();
 337   translate(0, 0, -1);
 338   float s = .07;
 339   scale(s, -s, s);
 340   image(logo, TRAILER_WIDTH/2/s-logo.width/2, TRAILER_HEIGHT/2/s-logo.height/2-2/s);
 341   popMatrix();
 342
 343   noStroke();
 344   if (glucose.model.bassBox.exists) {
 345     drawBassBox(glucose.model.bassBox, false);
 346   }
 347   for (Speaker speaker : glucose.model.speakers) {
 348     drawSpeaker(speaker);
 349   }
 350   for (Cube c : glucose.model.cubes) {
 351     drawCube(c);
 352   }
 353
 354   noFill();
 355   strokeWeight(2);
 356   beginShape(POINTS);
 357   for (Point p : glucose.model.points) {
 358     stroke(simulationColors[p.index]);
 359     vertex(p.x, p.y, p.z);
 360   }
 361   endShape();
 362 }
 363
 364 void drawBassBox(BassBox b, boolean hasSub) {
 365
 366   float in = .15;
 367
 368   if (hasSub) {
 369     noStroke();
 370     fill(#191919);
 371     pushMatrix();
 372     translate(b.x + BassBox.EDGE_WIDTH/2., b.y + BassBox.EDGE_HEIGHT/2, b.z + BassBox.EDGE_DEPTH/2.);
 373     box(BassBox.EDGE_WIDTH-20*in, BassBox.EDGE_HEIGHT-20*in, BassBox.EDGE_DEPTH-20*in);
 374     popMatrix();
 375   }
 376
 377   noStroke();
 378   fill(#393939);
 379   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);
 380
 381   pushMatrix();
 382   translate(b.x+(Cube.CHANNEL_WIDTH-in)/2., b.y + BassBox.EDGE_HEIGHT-in, b.z + BassBox.EDGE_DEPTH/2.);
 383   float lastOffset = 0;
 384   for (float offset : BoothFloor.STRIP_OFFSETS) {
 385     translate(offset - lastOffset, 0, 0);
 386     box(Cube.CHANNEL_WIDTH-in, 0, BassBox.EDGE_DEPTH - 2*in);
 387     lastOffset = offset;
 388   }
 389   popMatrix();
 390
 391   pushMatrix();
 392   translate(b.x + (Cube.CHANNEL_WIDTH-in)/2., b.y + BassBox.EDGE_HEIGHT/2., b.z + in);
 393   for (int j = 0; j < 2; ++j) {
 394     pushMatrix();
 395     for (int i = 0; i < BassBox.NUM_FRONT_STRUTS; ++i) {
 396       translate(BassBox.FRONT_STRUT_SPACING, 0, 0);
 397       box(Cube.CHANNEL_WIDTH-in, BassBox.EDGE_HEIGHT - in*2, 0);
 398     }
 399     popMatrix();
 400     translate(0, 0, BassBox.EDGE_DEPTH - 2*in);
 401   }
 402   popMatrix();
 403
 404   pushMatrix();
 405   translate(b.x + in, b.y + BassBox.EDGE_HEIGHT/2., b.z + BassBox.SIDE_STRUT_SPACING + (Cube.CHANNEL_WIDTH-in)/2.);
 406   box(0, BassBox.EDGE_HEIGHT - in*2, Cube.CHANNEL_WIDTH-in);
 407   translate(BassBox.EDGE_WIDTH-2*in, 0, 0);
 408   box(0, BassBox.EDGE_HEIGHT - in*2, Cube.CHANNEL_WIDTH-in);
 409   popMatrix();
 410
 411 }
 412
 413 void drawCube(Cube c) {
 414   float in = .15;
 415   noStroke();
 416   fill(#393939);
 417   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);
 418 }
 419
 420 void drawSpeaker(Speaker s) {
 421   float in = .15;
 422
 423   noStroke();
 424   fill(#191919);
 425   pushMatrix();
 426   translate(s.x, s.y, s.z);
 427   rotate(s.ry / 180. * PI, 0, -1, 0);
 428   translate(Speaker.EDGE_WIDTH/2., Speaker.EDGE_HEIGHT/2., Speaker.EDGE_DEPTH/2.);
 429   box(Speaker.EDGE_WIDTH-20*in, Speaker.EDGE_HEIGHT-20*in, Speaker.EDGE_DEPTH-20*in);
 430   translate(0, Speaker.EDGE_HEIGHT/2. + Speaker.EDGE_HEIGHT*.8/2, 0);
 431
 432   fill(#222222);
 433   box(Speaker.EDGE_WIDTH*.6, Speaker.EDGE_HEIGHT*.8, Speaker.EDGE_DEPTH*.75);
 434   popMatrix();
 435
 436   noStroke();
 437   fill(#393939);
 438   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);
 439 }
 440
 441 void drawBox(float x, float y, float z, float rx, float ry, float rz, float xd, float yd, float zd, float sw) {
 442   pushMatrix();
 443   translate(x, y, z);
 444   rotate(rx / 180. * PI, -1, 0, 0);
 445   rotate(ry / 180. * PI, 0, -1, 0);
 446   rotate(rz / 180. * PI, 0, 0, -1);
 447   for (int i = 0; i < 4; ++i) {
 448     float wid = (i % 2 == 0) ? xd : zd;
 449
 450     beginShape();
 451     vertex(0, 0);
 452     vertex(wid, 0);
 453     vertex(wid, yd);
 454     vertex(wid - sw, yd);
 455     vertex(wid - sw, sw);
 456     vertex(0, sw);
 457     endShape();
 458     beginShape();
 459     vertex(0, sw);
 460     vertex(0, yd);
 461     vertex(wid - sw, yd);
 462     vertex(wid - sw, yd - sw);
 463     vertex(sw, yd - sw);
 464     vertex(sw, sw);
 465     endShape();
 466
 467     translate(wid, 0, 0);
 468     rotate(HALF_PI, 0, -1, 0);
 469   }
 470   popMatrix();
 471 }
 472
 473 void drawUI() {
 474   camera();
 475   javax.media.opengl.GL gl = ((PGraphicsOpenGL)g).beginGL();
 476   gl.glClear(javax.media.opengl.GL.GL_DEPTH_BUFFER_BIT);
 477   ((PGraphicsOpenGL)g).endGL();
 478   strokeWeight(1);
 479
 480   if (uiOn) {
 481     for (UIContext context : overlays) {
 482       context.draw();
 483     }
 484   }
 485
 486   // Always draw FPS meter
 487   fill(#555555);
 488   textSize(9);
 489   textAlign(LEFT, BASELINE);
 490   text("FPS: " + ((int) (frameRate*10)) / 10. + " / " + targetFramerate + " (-/+)", 4, height-4);
 491
 492   if (debugMode) {
 493     debugUI.draw();
 494   }
 495 }
 496
 497
 498 /**
 499  * Top-level keyboard event handling
 500  */
 501 void keyPressed() {
 502   if (mappingMode) {
 503     mappingTool.keyPressed(uiMapping);
 504   }
 505   switch (key) {
 506     case '1':
 507     case '2':
 508     case '3':
 509     case '4':
 510     case '5':
 511     case '6':
 512     case '7':
 513     case '8':
 514       if (!midiEngine.isQwertyEnabled()) {
 515         presetManager.select(midiEngine.getFocusedDeck(), key - '1');
 516       }
 517       break;
 518
 519     case '!':
 520       if (!midiEngine.isQwertyEnabled()) presetManager.store(midiEngine.getFocusedDeck(), 0);
 521       break;
 522     case '@':
 523       if (!midiEngine.isQwertyEnabled()) presetManager.store(midiEngine.getFocusedDeck(), 1);
 524       break;
 525     case '#':
 526       if (!midiEngine.isQwertyEnabled()) presetManager.store(midiEngine.getFocusedDeck(), 2);
 527       break;
 528     case '$':
 529       if (!midiEngine.isQwertyEnabled()) presetManager.store(midiEngine.getFocusedDeck(), 3);
 530       break;
 531     case '%':
 532       if (!midiEngine.isQwertyEnabled()) presetManager.store(midiEngine.getFocusedDeck(), 4);
 533       break;
 534     case '^':
 535       if (!midiEngine.isQwertyEnabled()) presetManager.store(midiEngine.getFocusedDeck(), 5);
 536       break;
 537     case '&':
 538       if (!midiEngine.isQwertyEnabled()) presetManager.store(midiEngine.getFocusedDeck(), 6);
 539       break;
 540     case '*':
 541       if (!midiEngine.isQwertyEnabled()) presetManager.store(midiEngine.getFocusedDeck(), 7);
 542       break;
 543
 544     case '-':
 545     case '_':
 546       frameRate(--targetFramerate);
 547       break;
 548     case '=':
 549     case '+':
 550       frameRate(++targetFramerate);
 551       break;
 552     case 'b':
 553       effects.boom.trigger();
 554       break;
 555     case 'd':
 556       if (!midiEngine.isQwertyEnabled()) {
 557         debugMode = !debugMode;
 558         println("Debug output: " + (debugMode ? "ON" : "OFF"));
 559       }
 560       break;
 561     case 'm':
 562       if (!midiEngine.isQwertyEnabled()) {
 563         mappingMode = !mappingMode;
 564         uiPatternA.setVisible(!mappingMode);
 565         uiMapping.setVisible(mappingMode);
 566         if (mappingMode) {
 567           restoreToPattern = lx.getPattern();
 568           lx.setPatterns(new LXPattern[] { mappingTool });
 569         } else {
 570           lx.setPatterns(patterns);
 571           LXTransition pop = restoreToPattern.getTransition();
 572           restoreToPattern.setTransition(null);
 573           lx.goPattern(restoreToPattern);
 574           restoreToPattern.setTransition(pop);
 575         }
 576       }
 577       break;
 578     case 't':
 579       if (!midiEngine.isQwertyEnabled()) {
 580         lx.engine.setThreaded(!lx.engine.isThreaded());
 581       }
 582       break;
 583     case 'p':
 584       for (PandaDriver p : pandaBoards) {
 585         p.toggle();
 586       }
 587       break;
 588     case 'q':
 589       if (!midiEngine.isQwertyEnabled()) {
 590         diagnosticsOn = !diagnosticsOn;
 591       }
 592       break;
 593     case 's':
 594       if (!midiEngine.isQwertyEnabled()) {
 595         simulationOn = !simulationOn;
 596       }
 597       break;
 598     case 'u':
 599       if (!midiEngine.isQwertyEnabled()) {
 600         uiOn = !uiOn;
 601       }
 602       break;
 603   }
 604 }
 605
 606 /**
 607  * Top-level mouse event handling
 608  */
 609 int mx, my;
 610 void mousePressed() {
 611   boolean debugged = false;
 612   if (debugMode) {
 613     debugged = debugUI.mousePressed();
 614   }
 615   if (!debugged) {
 616     for (UIContext context : overlays) {
 617       context.mousePressed(mouseX, mouseY);
 618     }
 619   }
 620   mx = mouseX;
 621   my = mouseY;
 622 }
 623
 624 void mouseDragged() {
 625   boolean dragged = false;
 626   for (UIContext context : overlays) {
 627     dragged |= context.mouseDragged(mouseX, mouseY);
 628   }
 629   if (!dragged) {
 630     int dx = mouseX - mx;
 631     int dy = mouseY - my;
 632     mx = mouseX;
 633     my = mouseY;
 634     eyeA += dx*.003;
 635     eyeX = midX + eyeR*sin(eyeA);
 636     eyeZ = midZ + eyeR*cos(eyeA);
 637     eyeY += dy;
 638   }
 639 }
 640
 641 void mouseReleased() {
 642   for (UIContext context : overlays) {
 643     context.mouseReleased(mouseX, mouseY);
 644   }
 645 }
 646
 647 void mouseWheel(int delta) {
 648   boolean wheeled = false;
 649   for (UIContext context : overlays) {
 650     wheeled |= context.mouseWheel(mouseX, mouseY, delta);
 651   }
 652
 653   if (!wheeled) {
 654     eyeR = constrain(eyeR - delta, -500, -80);
 655     eyeX = midX + eyeR*sin(eyeA);
 656     eyeZ = midZ + eyeR*cos(eyeA);
 657   }
 658 }