Mapping modified kind of right
[SugarCubes.git] / _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 }