_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 = 7;
  44 final int NumBackTowers = 18;
  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   h = 5;
 303   noStroke();
 304   for (long val : new long[] {
 305     lx.engine.timer.deckNanos,
 306     lx.engine.timer.copyNanos,
 307     lx.engine.timer.fxNanos}) {
 308     float amt = val / (float) lx.timer.drawNanos;
 309     fill(lx.hsb(hv % 360, 100, 80));
 310     rect(xp, y, amt * tw, h-1);
 311     hv += 140;
 312     xp += amt * tw;
 313   }
 314
 315   xp = x;
 316   y += h;
 317   hv = 120;
 318   for (long val : new long[] {
 319     lx.engine.getDeck(0).timer.runNanos,
 320     lx.engine.getDeck(1).timer.runNanos,
 321     lx.engine.getDeck(1).getFaderTransition().timer.blendNanos}) {
 322     float amt = val / (float) lx.timer.drawNanos;
 323     fill(lx.hsb(hv % 360, 100, 80));
 324     rect(xp, y, amt * tw, h-1);
 325     hv += 140;
 326     xp += amt * tw;
 327   }
 328 }
 329
 330 void drawSimulation(color[] simulationColors) {
 331     camera(
 332     eyeX, eyeY, eyeZ,
 333     midX, midY, midZ,
 334     0, -1, 0
 335   );
 336
 337   translate(0, 40, 0);
 338
 339   noStroke();
 340   fill(#141414);
 341   drawBox(0, -TRAILER_HEIGHT, 0, 0, 0, 0, TRAILER_WIDTH, TRAILER_HEIGHT, TRAILER_DEPTH, TRAILER_HEIGHT/2.);
 342   fill(#070707);
 343   stroke(#222222);
 344   beginShape();
 345   vertex(0, 0, 0);
 346   vertex(TRAILER_WIDTH, 0, 0);
 347   vertex(TRAILER_WIDTH, 0, TRAILER_DEPTH);
 348   vertex(0, 0, TRAILER_DEPTH);
 349   endShape();
 350
 351   // Draw the logo on the front of platform
 352   pushMatrix();
 353   translate(0, 0, -1);
 354   float s = .07;
 355   scale(s, -s, s);
 356   image(logo, TRAILER_WIDTH/2/s-logo.width/2, TRAILER_HEIGHT/2/s-logo.height/2-2/s);
 357   popMatrix();
 358
 359   noStroke();
 360   if (glucose.model.bassBox.exists) {
 361     drawBassBox(glucose.model.bassBox, false);
 362   }
 363   for (Speaker speaker : glucose.model.speakers) {
 364     drawSpeaker(speaker);
 365   }
 366   for (Cube c : glucose.model.cubes) {
 367     drawCube(c);
 368   }
 369
 370   noFill();
 371   strokeWeight(2);
 372   beginShape(POINTS);
 373   for (Point p : glucose.model.points) {
 374     stroke(simulationColors[p.index]);
 375     vertex(p.x, p.y, p.z);
 376   }
 377   endShape();
 378 }
 379
 380 void drawBassBox(BassBox b, boolean hasSub) {
 381
 382   float in = .15;
 383
 384   if (hasSub) {
 385     noStroke();
 386     fill(#191919);
 387     pushMatrix();
 388     translate(b.x + BassBox.EDGE_WIDTH/2., b.y + BassBox.EDGE_HEIGHT/2, b.z + BassBox.EDGE_DEPTH/2.);
 389     box(BassBox.EDGE_WIDTH-20*in, BassBox.EDGE_HEIGHT-20*in, BassBox.EDGE_DEPTH-20*in);
 390     popMatrix();
 391   }
 392
 393   noStroke();
 394   fill(#393939);
 395   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);
 396
 397   pushMatrix();
 398   translate(b.x+(Cube.CHANNEL_WIDTH-in)/2., b.y + BassBox.EDGE_HEIGHT-in, b.z + BassBox.EDGE_DEPTH/2.);
 399   float lastOffset = 0;
 400   for (float offset : BoothFloor.STRIP_OFFSETS) {
 401     translate(offset - lastOffset, 0, 0);
 402     box(Cube.CHANNEL_WIDTH-in, 0, BassBox.EDGE_DEPTH - 2*in);
 403     lastOffset = offset;
 404   }
 405   popMatrix();
 406
 407   pushMatrix();
 408   translate(b.x + (Cube.CHANNEL_WIDTH-in)/2., b.y + BassBox.EDGE_HEIGHT/2., b.z + in);
 409   for (int j = 0; j < 2; ++j) {
 410     pushMatrix();
 411     for (int i = 0; i < BassBox.NUM_FRONT_STRUTS; ++i) {
 412       translate(BassBox.FRONT_STRUT_SPACING, 0, 0);
 413       box(Cube.CHANNEL_WIDTH-in, BassBox.EDGE_HEIGHT - in*2, 0);
 414     }
 415     popMatrix();
 416     translate(0, 0, BassBox.EDGE_DEPTH - 2*in);
 417   }
 418   popMatrix();
 419
 420   pushMatrix();
 421   translate(b.x + in, b.y + BassBox.EDGE_HEIGHT/2., b.z + BassBox.SIDE_STRUT_SPACING + (Cube.CHANNEL_WIDTH-in)/2.);
 422   box(0, BassBox.EDGE_HEIGHT - in*2, Cube.CHANNEL_WIDTH-in);
 423   translate(BassBox.EDGE_WIDTH-2*in, 0, 0);
 424   box(0, BassBox.EDGE_HEIGHT - in*2, Cube.CHANNEL_WIDTH-in);
 425   popMatrix();
 426
 427 }
 428
 429 void drawCube(Cube c) {
 430   float in = .15;
 431   noStroke();
 432   fill(#393939);
 433   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);
 434 }
 435
 436 void drawSpeaker(Speaker s) {
 437   float in = .15;
 438
 439   noStroke();
 440   fill(#191919);
 441   pushMatrix();
 442   translate(s.x, s.y, s.z);
 443   rotate(s.ry / 180. * PI, 0, -1, 0);
 444   translate(Speaker.EDGE_WIDTH/2., Speaker.EDGE_HEIGHT/2., Speaker.EDGE_DEPTH/2.);
 445   box(Speaker.EDGE_WIDTH-20*in, Speaker.EDGE_HEIGHT-20*in, Speaker.EDGE_DEPTH-20*in);
 446   translate(0, Speaker.EDGE_HEIGHT/2. + Speaker.EDGE_HEIGHT*.8/2, 0);
 447
 448   fill(#222222);
 449   box(Speaker.EDGE_WIDTH*.6, Speaker.EDGE_HEIGHT*.8, Speaker.EDGE_DEPTH*.75);
 450   popMatrix();
 451
 452   noStroke();
 453   fill(#393939);
 454   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);
 455 }
 456
 457 void drawBox(float x, float y, float z, float rx, float ry, float rz, float xd, float yd, float zd, float sw) {
 458   pushMatrix();
 459   translate(x, y, z);
 460   rotate(rx / 180. * PI, -1, 0, 0);
 461   rotate(ry / 180. * PI, 0, -1, 0);
 462   rotate(rz / 180. * PI, 0, 0, -1);
 463   for (int i = 0; i < 4; ++i) {
 464     float wid = (i % 2 == 0) ? xd : zd;
 465
 466     beginShape();
 467     vertex(0, 0);
 468     vertex(wid, 0);
 469     vertex(wid, yd);
 470     vertex(wid - sw, yd);
 471     vertex(wid - sw, sw);
 472     vertex(0, sw);
 473     endShape();
 474     beginShape();
 475     vertex(0, sw);
 476     vertex(0, yd);
 477     vertex(wid - sw, yd);
 478     vertex(wid - sw, yd - sw);
 479     vertex(sw, yd - sw);
 480     vertex(sw, sw);
 481     endShape();
 482
 483     translate(wid, 0, 0);
 484     rotate(HALF_PI, 0, -1, 0);
 485   }
 486   popMatrix();
 487 }
 488
 489 void drawUI() {
 490   camera();
 491   javax.media.opengl.GL gl = ((PGraphicsOpenGL)g).beginGL();
 492   gl.glClear(javax.media.opengl.GL.GL_DEPTH_BUFFER_BIT);
 493   ((PGraphicsOpenGL)g).endGL();
 494   strokeWeight(1);
 495
 496   if (uiOn) {
 497     for (UIContext context : overlays) {
 498       context.draw();
 499     }
 500   }
 501
 502   // Always draw FPS meter
 503   fill(#555555);
 504   textSize(9);
 505   textAlign(LEFT, BASELINE);
 506   text("FPS: " + ((int) (frameRate*10)) / 10. + " / " + targetFramerate + " (-/+)", 4, height-4);
 507
 508   if (debugMode) {
 509     debugUI.draw();
 510   }
 511 }
 512
 513
 514 /**
 515  * Top-level keyboard event handling
 516  */
 517 void keyPressed() {
 518   if (mappingMode) {
 519     mappingTool.keyPressed(uiMapping);
 520   }
 521   switch (key) {
 522     case '1':
 523     case '2':
 524     case '3':
 525     case '4':
 526     case '5':
 527     case '6':
 528     case '7':
 529     case '8':
 530       if (!midiEngine.isQwertyEnabled()) {
 531         presetManager.select(midiEngine.getFocusedDeck(), key - '1');
 532       }
 533       break;
 534
 535     case '!':
 536       if (!midiEngine.isQwertyEnabled()) presetManager.store(midiEngine.getFocusedDeck(), 0);
 537       break;
 538     case '@':
 539       if (!midiEngine.isQwertyEnabled()) presetManager.store(midiEngine.getFocusedDeck(), 1);
 540       break;
 541     case '#':
 542       if (!midiEngine.isQwertyEnabled()) presetManager.store(midiEngine.getFocusedDeck(), 2);
 543       break;
 544     case '$':
 545       if (!midiEngine.isQwertyEnabled()) presetManager.store(midiEngine.getFocusedDeck(), 3);
 546       break;
 547     case '%':
 548       if (!midiEngine.isQwertyEnabled()) presetManager.store(midiEngine.getFocusedDeck(), 4);
 549       break;
 550     case '^':
 551       if (!midiEngine.isQwertyEnabled()) presetManager.store(midiEngine.getFocusedDeck(), 5);
 552       break;
 553     case '&':
 554       if (!midiEngine.isQwertyEnabled()) presetManager.store(midiEngine.getFocusedDeck(), 6);
 555       break;
 556     case '*':
 557       if (!midiEngine.isQwertyEnabled()) presetManager.store(midiEngine.getFocusedDeck(), 7);
 558       break;
 559
 560     case '-':
 561     case '_':
 562       frameRate(--targetFramerate);
 563       break;
 564     case '=':
 565     case '+':
 566       frameRate(++targetFramerate);
 567       break;
 568     case 'b':
 569       effects.boom.trigger();
 570       break;
 571     case 'd':
 572       if (!midiEngine.isQwertyEnabled()) {
 573         debugMode = !debugMode;
 574         println("Debug output: " + (debugMode ? "ON" : "OFF"));
 575       }
 576       break;
 577     case 'm':
 578       if (!midiEngine.isQwertyEnabled()) {
 579         mappingMode = !mappingMode;
 580         uiPatternA.setVisible(!mappingMode);
 581         uiMapping.setVisible(mappingMode);
 582         if (mappingMode) {
 583           restoreToPattern = lx.getPattern();
 584           lx.setPatterns(new LXPattern[] { mappingTool });
 585         } else {
 586           lx.setPatterns(patterns);
 587           LXTransition pop = restoreToPattern.getTransition();
 588           restoreToPattern.setTransition(null);
 589           lx.goPattern(restoreToPattern);
 590           restoreToPattern.setTransition(pop);
 591         }
 592       }
 593       break;
 594     case 't':
 595       if (!midiEngine.isQwertyEnabled()) {
 596         lx.engine.setThreaded(!lx.engine.isThreaded());
 597       }
 598       break;
 599     case 'p':
 600       for (PandaDriver p : pandaBoards) {
 601         p.toggle();
 602       }
 603       break;
 604     case 'q':
 605       if (!midiEngine.isQwertyEnabled()) {
 606         diagnosticsOn = !diagnosticsOn;
 607       }
 608       break;
 609     case 's':
 610       if (!midiEngine.isQwertyEnabled()) {
 611         simulationOn = !simulationOn;
 612       }
 613       break;
 614     case 'u':
 615       if (!midiEngine.isQwertyEnabled()) {
 616         uiOn = !uiOn;
 617       }
 618       break;
 619   }
 620 }
 621
 622 /**
 623  * Top-level mouse event handling
 624  */
 625 int mx, my;
 626 void mousePressed() {
 627   boolean debugged = false;
 628   if (debugMode) {
 629     debugged = debugUI.mousePressed();
 630   }
 631   if (!debugged) {
 632     for (UIContext context : overlays) {
 633       context.mousePressed(mouseX, mouseY);
 634     }
 635   }
 636   mx = mouseX;
 637   my = mouseY;
 638 }
 639
 640 void mouseDragged() {
 641   boolean dragged = false;
 642   for (UIContext context : overlays) {
 643     dragged |= context.mouseDragged(mouseX, mouseY);
 644   }
 645   if (!dragged) {
 646     int dx = mouseX - mx;
 647     int dy = mouseY - my;
 648     mx = mouseX;
 649     my = mouseY;
 650     eyeA += dx*.003;
 651     eyeX = midX + eyeR*sin(eyeA);
 652     eyeZ = midZ + eyeR*cos(eyeA);
 653     eyeY += dy;
 654   }
 655 }
 656
 657 void mouseReleased() {
 658   for (UIContext context : overlays) {
 659     context.mouseReleased(mouseX, mouseY);
 660   }
 661 }
 662
 663 void mouseWheel(int delta) {
 664   boolean wheeled = false;
 665   for (UIContext context : overlays) {
 666     wheeled |= context.mouseWheel(mouseX, mouseY, delta);
 667   }
 668
 669   if (!wheeled) {
 670     eyeR = constrain(eyeR - delta, -500, -80);
 671     eyeX = midX + eyeR*sin(eyeA);
 672     eyeZ = midZ + eyeR*cos(eyeA);
 673   }
 674 }