[SugarCubes.git] / _Internals.pde

/**
 *     DOUBLE BLACK DIAMOND        DOUBLE BLACK DIAMOND
 *
 *         //\\   //\\                 //\\   //\\  
 *        ///\\\ ///\\\               ///\\\ ///\\\
 *        \\\/// \\\///               \\\/// \\\///
 *         \\//   \\//                 \\//   \\//
 *
 *        EXPERTS ONLY!!              EXPERTS ONLY!!
 *
 * If you are an artist, you may ignore this file! It just sets
 * up the framework to run the patterns. Should not need modification
 * for general animation work.
 */

import glucose.*;
import glucose.control.*;
import glucose.effect.*;
import glucose.model.*;
import glucose.pattern.*;
import glucose.transform.*;
import glucose.transition.*;
import heronarts.lx.*;
import heronarts.lx.control.*;
import heronarts.lx.effect.*;
import heronarts.lx.modulator.*;
import heronarts.lx.pattern.*;
import heronarts.lx.transition.*;
import ddf.minim.*;
import ddf.minim.analysis.*;
import processing.opengl.*;
import rwmidi.*;

final int VIEWPORT_WIDTH = 900;
final int VIEWPORT_HEIGHT = 700;

// The trailer is measured from the outside of the black metal (but not including the higher welded part on the front)
final float TRAILER_WIDTH = 240;
final float TRAILER_DEPTH = 97;
final float TRAILER_HEIGHT = 33;

int targetFramerate = 60;

int startMillis, lastMillis;
GLucose glucose;
HeronLX lx;
MappingTool mappingTool;
LXPattern[] patterns;
LXTransition[] transitions;
LXEffect[] effects;
OverlayUI ui;
ControlUI controlUI;
MappingUI mappingUI;
PandaDriver[] pandaBoards;
boolean mappingMode = false;
boolean debugMode = false;
DebugUI debugUI;

// Camera variables
float eyeR, eyeA, eyeX, eyeY, eyeZ, midX, midY, midZ;

void setup() {
  startMillis = lastMillis = millis();

  // Initialize the Processing graphics environment
  size(VIEWPORT_WIDTH, VIEWPORT_HEIGHT, OPENGL);
  frameRate(targetFramerate);
  noSmooth();
  // hint(ENABLE_OPENGL_4X_SMOOTH); // no discernable improvement?
  logTime("Created viewport");

  // Create the GLucose engine to run the cubes
  glucose = new GLucose(this, buildModel());
  lx = glucose.lx;
  lx.enableKeyboardTempo();
  logTime("Built GLucose engine");
  
  // Set the patterns
  glucose.lx.setPatterns(patterns = patterns(glucose));
  logTime("Built patterns");
  glucose.lx.addEffects(effects = effects(glucose));
  logTime("Built effects");
  glucose.setTransitions(transitions = transitions(glucose));
  logTime("Built transitions");
    
  // Build output driver
  PandaMapping[] pandaMappings = buildPandaList();
  pandaBoards = new PandaDriver[pandaMappings.length];
  int pbi = 0;
  for (PandaMapping pm : pandaMappings) {
    pandaBoards[pbi++] = new PandaDriver(pm.ip, glucose.model, pm);
  }
  mappingTool = new MappingTool(glucose, pandaMappings);
  logTime("Built PandaDriver");
  
  // Build overlay UI
  ui = controlUI = new ControlUI();
  mappingUI = new MappingUI(mappingTool);
  debugUI = new DebugUI(pandaMappings);
  logTime("Built overlay UI");
    
  // MIDI devices
  for (MidiInputDevice d : RWMidi.getInputDevices()) {
    d.createInput(this);
  }
  SCMidiDevices.initializeStandardDevices(glucose);
  logTime("Setup MIDI devices");
    
  // Setup camera
  midX = TRAILER_WIDTH/2. + 20;
  midY = glucose.model.yMax/2;
  midZ = TRAILER_DEPTH/2.;
  eyeR = -290;
  eyeA = .15;
  eyeY = midY + 20;
  eyeX = midX + eyeR*sin(eyeA);
  eyeZ = midZ + eyeR*cos(eyeA);
  addMouseWheelListener(new java.awt.event.MouseWheelListener() { 
    public void mouseWheelMoved(java.awt.event.MouseWheelEvent mwe) { 
      mouseWheel(mwe.getWheelRotation());
  }}); 
  
  println("Total setup: " + (millis() - startMillis) + "ms");
  println("Hit the 'p' key to toggle Panda Board output");
}

void controllerChangeReceived(rwmidi.Controller cc) {
  if (debugMode) {
    println("CC: " + cc.toString());
  }
}

void noteOnReceived(Note note) {
  if (debugMode) {
    println("Note On: " + note.toString());
  }
}

void noteOffReceived(Note note) {
  if (debugMode) {
    println("Note Off: " + note.toString());
  }
}

void logTime(String evt) {
  int now = millis();
  println(evt + ": " + (now - lastMillis) + "ms");
  lastMillis = now;
}

void draw() {
  // Draws the simulation and the 2D UI overlay
  background(40);
  color[] colors = glucose.getColors();
  if (debugMode) {
    debugUI.maskColors(colors);
  }

  camera(
    eyeX, eyeY, eyeZ,
    midX, midY, midZ,
    0, -1, 0
  );

  noStroke();
  fill(#141414);
  drawBox(0, -TRAILER_HEIGHT, 0, 0, 0, 0, TRAILER_WIDTH, TRAILER_HEIGHT, TRAILER_DEPTH, TRAILER_HEIGHT/2.);
  fill(#070707);
  stroke(#222222);
  beginShape();
  vertex(0, 0, 0);
  vertex(TRAILER_WIDTH, 0, 0);
  vertex(TRAILER_WIDTH, 0, TRAILER_DEPTH);
  vertex(0, 0, TRAILER_DEPTH);
  endShape();
  
  noStroke();
  drawBassBox(glucose.model.bassBox);
  for (Speaker s : glucose.model.speakers) {
    drawSpeaker(s);
  }
  for (Cube c : glucose.model.cubes) {
    drawCube(c);
  }

  noFill();
  strokeWeight(2);
  beginShape(POINTS);
  for (Point p : glucose.model.points) {
    stroke(colors[p.index]);
    vertex(p.fx, p.fy, p.fz);
  }
  endShape();
  
  // 2D Overlay
  camera();
  javax.media.opengl.GL gl = ((PGraphicsOpenGL)g).beginGL();
  gl.glClear(javax.media.opengl.GL.GL_DEPTH_BUFFER_BIT);
  ((PGraphicsOpenGL)g).endGL();
  strokeWeight(1);
  drawUI();
  
  if (debugMode) {
    debugUI.draw();
  }
  
  // TODO(dan): if you want to, here would be a good place to
  // put in gamma correction, modifying the colors that get
  // sent to the pandaboards, without mucking up the UI here
  
  // TODO(mcslee): move into GLucose engine
  for (PandaDriver p : pandaBoards) {
    p.send(colors);
  }
}

void drawBassBox(BassBox b) {
  float in = .15;

  noStroke();
  fill(#191919);
  pushMatrix();
  translate(b.x + BassBox.EDGE_WIDTH/2., b.y + BassBox.EDGE_HEIGHT/2, b.z + BassBox.EDGE_DEPTH/2.);
  box(BassBox.EDGE_WIDTH-20*in, BassBox.EDGE_HEIGHT-20*in, BassBox.EDGE_DEPTH-20*in);
  popMatrix();

  noStroke();
  fill(#393939);
  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);

  pushMatrix();
  translate(b.x+(Cube.CHANNEL_WIDTH-in)/2., b.y + BassBox.EDGE_HEIGHT-in, b.z + BassBox.EDGE_DEPTH/2.);
  float lastOffset = 0;
  for (float offset : BoothFloor.STRIP_OFFSETS) {
    translate(offset - lastOffset, 0, 0);
    box(Cube.CHANNEL_WIDTH-in, 0, BassBox.EDGE_DEPTH - 2*in);
    lastOffset = offset;
  }
  popMatrix();

  pushMatrix();
  translate(b.x + (Cube.CHANNEL_WIDTH-in)/2., b.y + BassBox.EDGE_HEIGHT/2., b.z + in);
  for (int j = 0; j < 2; ++j) {
    pushMatrix();
    for (int i = 0; i < BassBox.NUM_FRONT_STRUTS; ++i) {
      translate(BassBox.FRONT_STRUT_SPACING, 0, 0);
      box(Cube.CHANNEL_WIDTH-in, BassBox.EDGE_HEIGHT - in*2, 0);
    }
    popMatrix();
    translate(0, 0, BassBox.EDGE_DEPTH - 2*in);
  }
  popMatrix();
  
  pushMatrix();
  translate(b.x + in, b.y + BassBox.EDGE_HEIGHT/2., b.z + BassBox.SIDE_STRUT_SPACING + (Cube.CHANNEL_WIDTH-in)/2.);
  box(0, BassBox.EDGE_HEIGHT - in*2, Cube.CHANNEL_WIDTH-in);
  translate(BassBox.EDGE_WIDTH-2*in, 0, 0);
  box(0, BassBox.EDGE_HEIGHT - in*2, Cube.CHANNEL_WIDTH-in);
  popMatrix();
  
}

void drawCube(Cube c) {
  float in = .15;
  noStroke();
  fill(#393939);  
  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);
}

void drawSpeaker(Speaker s) {
  float in = .15;
  
  noStroke();
  fill(#191919);
  pushMatrix();
  translate(s.x, s.y, s.z);
  rotate(s.ry / 180. * PI, 0, -1, 0);
  translate(Speaker.EDGE_WIDTH/2., Speaker.EDGE_HEIGHT/2., Speaker.EDGE_DEPTH/2.);
  box(Speaker.EDGE_WIDTH-20*in, Speaker.EDGE_HEIGHT-20*in, Speaker.EDGE_DEPTH-20*in);
  translate(0, Speaker.EDGE_HEIGHT/2. + Speaker.EDGE_HEIGHT*.8/2, 0);

  fill(#222222);
  box(Speaker.EDGE_WIDTH*.6, Speaker.EDGE_HEIGHT*.8, Speaker.EDGE_DEPTH*.75);
  popMatrix();
  
  noStroke();
  fill(#393939);  
  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);
}  


void drawBox(float x, float y, float z, float rx, float ry, float rz, float xd, float yd, float zd, float sw) {
  pushMatrix();
  translate(x, y, z);
  rotate(rx / 180. * PI, -1, 0, 0);
  rotate(ry / 180. * PI, 0, -1, 0);
  rotate(rz / 180. * PI, 0, 0, -1);
  for (int i = 0; i < 4; ++i) {
    float wid = (i % 2 == 0) ? xd : zd;
    
    beginShape();
    vertex(0, 0);
    vertex(wid, 0);
    vertex(wid, yd);
    vertex(wid - sw, yd);
    vertex(wid - sw, sw);
    vertex(0, sw);
    endShape();
    beginShape();
    vertex(0, sw);
    vertex(0, yd);
    vertex(wid - sw, yd);
    vertex(wid - sw, yd - sw);
    vertex(sw, yd - sw);
    vertex(sw, sw);
    endShape();

    translate(wid, 0, 0);
    rotate(HALF_PI, 0, -1, 0);
  }
  popMatrix();
}

void drawUI() {
  if (uiOn) {
    ui.draw();
  } else {
    ui.drawHelpTip();
  }
  ui.drawFPS();
}

boolean uiOn = true;
int restoreToIndex = -1;

void keyPressed() {
  if (mappingMode) {
    mappingTool.keyPressed();
  }
  switch (key) {
    case '-':
    case '_':
      frameRate(--targetFramerate);
      break;
    case '=':
    case '+':
      frameRate(++targetFramerate);
      break;
    case 'd':
      debugMode = !debugMode;
      println("Debug output: " + (debugMode ? "ON" : "OFF"));
      break;
    case 'm':
      mappingMode = !mappingMode;
      if (mappingMode) {
        LXPattern pattern = lx.getPattern();
        for (int i = 0; i < patterns.length; ++i) {
          if (pattern == patterns[i]) {
            restoreToIndex = i;
            break;
          }
        }
        ui = mappingUI;
        lx.setPatterns(new LXPattern[] { mappingTool });
      } else {
        ui = controlUI;
        lx.setPatterns(patterns);
        lx.goIndex(restoreToIndex);
      }
      break;
    case 'p':
      for (PandaDriver p : pandaBoards) {
        p.toggle();
      }
      break;
    case 'u':
      uiOn = !uiOn;
      break;
  }
}

int mx, my;
void mousePressed() {
  ui.mousePressed();
  if (mouseX < ui.leftPos) {
    if (debugMode) {
      debugUI.mousePressed();
    }    
    mx = mouseX;
    my = mouseY;
  }
}

void mouseDragged() {
  if (mouseX > ui.leftPos) {
    ui.mouseDragged();
  } else {
    int dx = mouseX - mx;
    int dy = mouseY - my;
    mx = mouseX;
    my = mouseY;
    eyeA += dx*.003;
    eyeX = midX + eyeR*sin(eyeA);
    eyeZ = midZ + eyeR*cos(eyeA);
    eyeY += dy;
  }
}

void mouseReleased() {
  ui.mouseReleased();
}
 
void mouseWheel(int delta) {
  if (mouseX > ui.leftPos) {
    ui.mouseWheel(delta);
  } else {
    eyeR = constrain(eyeR - delta, -500, -80);
    eyeX = midX + eyeR*sin(eyeA);
    eyeZ = midZ + eyeR*cos(eyeA);
  }
}
Commit	Line	Data
	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	void controllerChangeReceived(rwmidi.Controller cc) {
	128	if (debugMode) {
	129	println("CC: " + cc.toString());
	130	}
	131	}
	132
	133	void noteOnReceived(Note note) {
	134	if (debugMode) {
	135	println("Note On: " + note.toString());
	136	}
	137	}
	138
	139	void noteOffReceived(Note note) {
	140	if (debugMode) {
	141	println("Note Off: " + note.toString());
	142	}
	143	}
	144
	145	void logTime(String evt) {
	146	int now = millis();
	147	println(evt + ": " + (now - lastMillis) + "ms");
	148	lastMillis = now;
	149	}
	150
	151	void draw() {
	152	// Draws the simulation and the 2D UI overlay
	153	background(40);
	154	color[] colors = glucose.getColors();
	155	if (debugMode) {
	156	debugUI.maskColors(colors);
	157	}
	158
	159	camera(
	160	eyeX, eyeY, eyeZ,
	161	midX, midY, midZ,
	162	0, -1, 0
	163	);
	164
	165	noStroke();
	166	fill(#141414);
	167	drawBox(0, -TRAILER_HEIGHT, 0, 0, 0, 0, TRAILER_WIDTH, TRAILER_HEIGHT, TRAILER_DEPTH, TRAILER_HEIGHT/2.);
	168	fill(#070707);
	169	stroke(#222222);
	170	beginShape();
	171	vertex(0, 0, 0);
	172	vertex(TRAILER_WIDTH, 0, 0);
	173	vertex(TRAILER_WIDTH, 0, TRAILER_DEPTH);
	174	vertex(0, 0, TRAILER_DEPTH);
	175	endShape();
	176
	177	noStroke();
	178	drawBassBox(glucose.model.bassBox);
	179	for (Speaker s : glucose.model.speakers) {
	180	drawSpeaker(s);
	181	}
	182	for (Cube c : glucose.model.cubes) {
	183	drawCube(c);
	184	}
	185
	186	noFill();
	187	strokeWeight(2);
	188	beginShape(POINTS);
	189	for (Point p : glucose.model.points) {
	190	stroke(colors[p.index]);
	191	vertex(p.fx, p.fy, p.fz);
	192	}
	193	endShape();
	194
	195	// 2D Overlay
	196	camera();
	197	javax.media.opengl.GL gl = ((PGraphicsOpenGL)g).beginGL();
	198	gl.glClear(javax.media.opengl.GL.GL_DEPTH_BUFFER_BIT);
	199	((PGraphicsOpenGL)g).endGL();
	200	strokeWeight(1);
	201	drawUI();
	202
	203	if (debugMode) {
	204	debugUI.draw();
	205	}
	206
	207	// TODO(dan): if you want to, here would be a good place to
	208	// put in gamma correction, modifying the colors that get
	209	// sent to the pandaboards, without mucking up the UI here
	210
	211	// TODO(mcslee): move into GLucose engine
	212	for (PandaDriver p : pandaBoards) {
	213	p.send(colors);
	214	}
	215	}
	216
	217	void drawBassBox(BassBox b) {
	218	float in = .15;
	219
	220	noStroke();
	221	fill(#191919);
	222	pushMatrix();
	223	translate(b.x + BassBox.EDGE_WIDTH/2., b.y + BassBox.EDGE_HEIGHT/2, b.z + BassBox.EDGE_DEPTH/2.);
	224	box(BassBox.EDGE_WIDTH-20in, BassBox.EDGE_HEIGHT-20in, BassBox.EDGE_DEPTH-20*in);
	225	popMatrix();
	226
	227	noStroke();
	228	fill(#393939);
	229	drawBox(b.x+in, b.y+in, b.z+in, 0, 0, 0, BassBox.EDGE_WIDTH-in2, BassBox.EDGE_HEIGHT-in2, BassBox.EDGE_DEPTH-in*2, Cube.CHANNEL_WIDTH-in);
	230
	231	pushMatrix();
	232	translate(b.x+(Cube.CHANNEL_WIDTH-in)/2., b.y + BassBox.EDGE_HEIGHT-in, b.z + BassBox.EDGE_DEPTH/2.);
	233	float lastOffset = 0;
	234	for (float offset : BoothFloor.STRIP_OFFSETS) {
	235	translate(offset - lastOffset, 0, 0);
	236	box(Cube.CHANNEL_WIDTH-in, 0, BassBox.EDGE_DEPTH - 2*in);
	237	lastOffset = offset;
	238	}
	239	popMatrix();
	240
	241	pushMatrix();
	242	translate(b.x + (Cube.CHANNEL_WIDTH-in)/2., b.y + BassBox.EDGE_HEIGHT/2., b.z + in);
	243	for (int j = 0; j < 2; ++j) {
	244	pushMatrix();
	245	for (int i = 0; i < BassBox.NUM_FRONT_STRUTS; ++i) {
	246	translate(BassBox.FRONT_STRUT_SPACING, 0, 0);
	247	box(Cube.CHANNEL_WIDTH-in, BassBox.EDGE_HEIGHT - in*2, 0);
	248	}
	249	popMatrix();
	250	translate(0, 0, BassBox.EDGE_DEPTH - 2*in);
	251	}
	252	popMatrix();
	253
	254	pushMatrix();
	255	translate(b.x + in, b.y + BassBox.EDGE_HEIGHT/2., b.z + BassBox.SIDE_STRUT_SPACING + (Cube.CHANNEL_WIDTH-in)/2.);
	256	box(0, BassBox.EDGE_HEIGHT - in*2, Cube.CHANNEL_WIDTH-in);
	257	translate(BassBox.EDGE_WIDTH-2*in, 0, 0);
	258	box(0, BassBox.EDGE_HEIGHT - in*2, Cube.CHANNEL_WIDTH-in);
	259	popMatrix();
	260
	261	}
	262
	263	void drawCube(Cube c) {
	264	float in = .15;
	265	noStroke();
	266	fill(#393939);
	267	drawBox(c.x+in, c.y+in, c.z+in, c.rx, c.ry, c.rz, Cube.EDGE_WIDTH-in2, Cube.EDGE_HEIGHT-in2, Cube.EDGE_WIDTH-in*2, Cube.CHANNEL_WIDTH-in);
	268	}
	269
	270	void drawSpeaker(Speaker s) {
	271	float in = .15;
	272
	273	noStroke();
	274	fill(#191919);
	275	pushMatrix();
	276	translate(s.x, s.y, s.z);
	277	rotate(s.ry / 180. * PI, 0, -1, 0);
	278	translate(Speaker.EDGE_WIDTH/2., Speaker.EDGE_HEIGHT/2., Speaker.EDGE_DEPTH/2.);
	279	box(Speaker.EDGE_WIDTH-20in, Speaker.EDGE_HEIGHT-20in, Speaker.EDGE_DEPTH-20*in);
	280	translate(0, Speaker.EDGE_HEIGHT/2. + Speaker.EDGE_HEIGHT*.8/2, 0);
	281
	282	fill(#222222);
	283	box(Speaker.EDGE_WIDTH.6, Speaker.EDGE_HEIGHT.8, Speaker.EDGE_DEPTH*.75);
	284	popMatrix();
	285
	286	noStroke();
	287	fill(#393939);
	288	drawBox(s.x+in, s.y+in, s.z+in, 0, s.ry, 0, Speaker.EDGE_WIDTH-in2, Speaker.EDGE_HEIGHT-in2, Speaker.EDGE_DEPTH-in*2, Cube.CHANNEL_WIDTH-in);
	289	}
	290
	291
	292	void drawBox(float x, float y, float z, float rx, float ry, float rz, float xd, float yd, float zd, float sw) {
	293	pushMatrix();
	294	translate(x, y, z);
	295	rotate(rx / 180. * PI, -1, 0, 0);
	296	rotate(ry / 180. * PI, 0, -1, 0);
	297	rotate(rz / 180. * PI, 0, 0, -1);
	298	for (int i = 0; i < 4; ++i) {
	299	float wid = (i % 2 == 0) ? xd : zd;
	300
	301	beginShape();
	302	vertex(0, 0);
	303	vertex(wid, 0);
	304	vertex(wid, yd);
	305	vertex(wid - sw, yd);
	306	vertex(wid - sw, sw);
	307	vertex(0, sw);
	308	endShape();
	309	beginShape();
	310	vertex(0, sw);
	311	vertex(0, yd);
	312	vertex(wid - sw, yd);
	313	vertex(wid - sw, yd - sw);
	314	vertex(sw, yd - sw);
	315	vertex(sw, sw);
	316	endShape();
	317
	318	translate(wid, 0, 0);
	319	rotate(HALF_PI, 0, -1, 0);
	320	}
	321	popMatrix();
	322	}
	323
	324	void drawUI() {
	325	if (uiOn) {
	326	ui.draw();
	327	} else {
	328	ui.drawHelpTip();
	329	}
	330	ui.drawFPS();
	331	}
	332
	333	boolean uiOn = true;
	334	int restoreToIndex = -1;
	335
	336	void keyPressed() {
	337	if (mappingMode) {
	338	mappingTool.keyPressed();
	339	}
	340	switch (key) {
	341	case '-':
	342	case '_':
	343	frameRate(--targetFramerate);
	344	break;
	345	case '=':
	346	case '+':
	347	frameRate(++targetFramerate);
	348	break;
	349	case 'd':
	350	debugMode = !debugMode;
	351	println("Debug output: " + (debugMode ? "ON" : "OFF"));
	352	break;
	353	case 'm':
	354	mappingMode = !mappingMode;
	355	if (mappingMode) {
	356	LXPattern pattern = lx.getPattern();
	357	for (int i = 0; i < patterns.length; ++i) {
	358	if (pattern == patterns[i]) {
	359	restoreToIndex = i;
	360	break;
	361	}
	362	}
	363	ui = mappingUI;
	364	lx.setPatterns(new LXPattern[] { mappingTool });
	365	} else {
	366	ui = controlUI;
	367	lx.setPatterns(patterns);
	368	lx.goIndex(restoreToIndex);
	369	}
	370	break;
	371	case 'p':
	372	for (PandaDriver p : pandaBoards) {
	373	p.toggle();
	374	}
	375	break;
	376	case 'u':
	377	uiOn = !uiOn;
	378	break;
	379	}
	380	}
	381
	382	int mx, my;
	383	void mousePressed() {
	384	ui.mousePressed();
	385	if (mouseX < ui.leftPos) {
	386	if (debugMode) {
	387	debugUI.mousePressed();
	388	}
	389	mx = mouseX;
	390	my = mouseY;
	391	}
	392	}
	393
	394	void mouseDragged() {
	395	if (mouseX > ui.leftPos) {
	396	ui.mouseDragged();
	397	} else {
	398	int dx = mouseX - mx;
	399	int dy = mouseY - my;
	400	mx = mouseX;
	401	my = mouseY;
	402	eyeA += dx*.003;
	403	eyeX = midX + eyeR*sin(eyeA);
	404	eyeZ = midZ + eyeR*cos(eyeA);
	405	eyeY += dy;
	406	}
	407	}
	408
	409	void mouseReleased() {
	410	ui.mouseReleased();
	411	}
	412
	413	void mouseWheel(int delta) {
	414	if (mouseX > ui.leftPos) {
	415	ui.mouseWheel(delta);
	416	} else {
	417	eyeR = constrain(eyeR - delta, -500, -80);
	418	eyeX = midX + eyeR*sin(eyeA);
	419	eyeZ = midZ + eyeR*cos(eyeA);
	420	}
	421	}
	422