protected final float knobIndent = .4;
protected final int knobSpacing = 6;
protected final int knobLabelHeight = 14;
+ protected final int scrollWidth = 14;
protected final color lightBlue = #666699;
protected final color lightGreen = #669966;
textFont(titleFont);
textAlign(LEFT);
fill(#666666);
- text("FPS: " + (((int)(frameRate * 10)) / 10.), 4, height-6);
+ text("FPS: " + (((int)(frameRate * 10)) / 10.), 4, height-6);
+ text("Target (-/+):", 50, height-6);
+ fill(#000000);
+ rect(104, height-16, 20, 12);
+ fill(#666666);
+ text("" + targetFramerate, 108, height-6);
+ text("PandaOutput (p):", 134, height-6);
+ fill(#000000);
+ rect(214, height-16, 26, 12);
+ fill(#666666);
+ text(pandaBoardsEnabled ? "ON" : "OFF", 218, height-6);
+
}
protected int drawObjectList(int yPos, String title, Object[] items, Method stateMethod) {
- return drawObjectList(yPos, title, items, classNameArray(items, null), stateMethod);
+ int sz = (items != null) ? items.length : 0;
+ return drawObjectList(yPos, title, items, stateMethod, sz, 0);
}
-
+
+ protected int drawObjectList(int yPos, String title, Object[] items, Method stateMethod, int scrollLength, int scrollPos) {
+ return drawObjectList(yPos, title, items, classNameArray(items, null), stateMethod, scrollLength, scrollPos);
+ }
+
protected int drawObjectList(int yPos, String title, Object[] items, String[] names, Method stateMethod) {
+ int sz = (items != null) ? items.length : 0;
+ return drawObjectList(yPos, title, items, names, stateMethod, sz, 0);
+ }
+
+ protected int drawObjectList(int yPos, String title, Object[] items, String[] names, Method stateMethod, int scrollLength, int scrollPos) {
noStroke();
fill(titleColor);
textFont(titleFont);
textFont(itemFont);
color textColor;
boolean even = true;
- for (int i = 0; i < items.length; ++i) {
+ int yTop = yPos+6;
+ for (int i = scrollPos; i < items.length && i < (scrollPos + scrollLength); ++i) {
Object o = items[i];
int state = STATE_DEFAULT;
try {
fill(even ? #666666 : #777777);
break;
}
- rect(leftPos, yPos+6, width, lineHeight);
+ rect(leftPos, yPos+6, w, lineHeight);
fill(textColor);
text(names[i], leftTextPos, yPos += lineHeight);
even = !even;
}
+ if ((scrollPos > 0) || (scrollLength < items.length)) {
+ int yHere = yPos+6;
+ noStroke();
+ fill(color(0, 0, 0, 50));
+ rect(leftPos + w - scrollWidth, yTop, scrollWidth, yHere - yTop);
+ fill(#666666);
+ rect(leftPos + w - scrollWidth + 2, yTop + (yHere-yTop) * (scrollPos / (float)items.length), scrollWidth - 4, (yHere - yTop) * (scrollLength / (float)items.length));
+
+ }
+
}
return yPos;
}
return (mouseY - firstItemY) / lineHeight;
}
- abstract public void draw();
+ abstract public void draw();
abstract public void mousePressed();
abstract public void mouseDragged();
abstract public void mouseReleased();
+ abstract public void mouseWheel(int delta);
}
/**
private int firstTransitionKnobY;
private int firstEffectY;
private int firstEffectKnobY;
+
+ private final int PATTERN_LIST_LENGTH = 8;
+ private int patternScrollPos = 0;
private int tempoY;
private Method patternStateMethod;
private Method transitionStateMethod;
private Method effectStateMethod;
-
- private final int NUM_PATTERN_KNOBS = 8;
- private final int NUM_TRANSITION_KNOBS = 4;
- private final int NUM_EFFECT_KNOBS = 4;
-
- private int activeTransitionIndex = 0;
- private int activeEffectIndex = 0;
-
- public final VirtualPatternKnob[] patternKnobs;
- public final VirtualTransitionKnob[] transitionKnobs;
- public final VirtualEffectKnob[] effectKnobs;
-
+
ControlUI() {
patternNames = classNameArray(patterns, "Pattern");
transitionNames = classNameArray(transitions, "Transition");
effectNames = classNameArray(effects, "Effect");
- patternKnobs = new VirtualPatternKnob[NUM_PATTERN_KNOBS];
- for (int i = 0; i < patternKnobs.length; ++i) {
- patternKnobs[i] = new VirtualPatternKnob(i);
- }
-
- transitionKnobs = new VirtualTransitionKnob[NUM_TRANSITION_KNOBS];
- for (int i = 0; i < transitionKnobs.length; ++i) {
- transitionKnobs[i] = new VirtualTransitionKnob(i);
- }
-
- effectKnobs = new VirtualEffectKnob[NUM_EFFECT_KNOBS];
- for (int i = 0; i < effectKnobs.length; ++i) {
- effectKnobs[i] = new VirtualEffectKnob(i);
- }
-
try {
patternStateMethod = getClass().getMethod("getState", LXPattern.class);
effectStateMethod = getClass().getMethod("getState", LXEffect.class);
drawLogoAndBackground();
int yPos = 0;
firstPatternY = yPos + lineHeight + 6;
- yPos = drawObjectList(yPos, "PATTERN", patterns, patternNames, patternStateMethod);
+ yPos = drawObjectList(yPos, "PATTERN", patterns, patternNames, patternStateMethod, PATTERN_LIST_LENGTH, patternScrollPos);
yPos += controlSpacing;
firstPatternKnobY = yPos;
int xPos = leftTextPos;
- for (int i = 0; i < NUM_PATTERN_KNOBS/2; ++i) {
- drawKnob(xPos, yPos, knobSize, patternKnobs[i]);
- drawKnob(xPos, yPos + knobSize + knobSpacing + knobLabelHeight, knobSize, patternKnobs[NUM_PATTERN_KNOBS/2 + i]);
+ for (int i = 0; i < glucose.NUM_PATTERN_KNOBS/2; ++i) {
+ drawKnob(xPos, yPos, knobSize, glucose.patternKnobs.get(i));
+ drawKnob(xPos, yPos + knobSize + knobSpacing + knobLabelHeight, knobSize, glucose.patternKnobs.get(glucose.NUM_PATTERN_KNOBS/2 + i));
xPos += knobSize + knobSpacing;
}
yPos += 2*(knobSize + knobLabelHeight) + knobSpacing;
yPos += controlSpacing;
firstTransitionKnobY = yPos;
xPos = leftTextPos;
- for (int i = 0; i < transitionKnobs.length; ++i) {
- drawKnob(xPos, yPos, knobSize, transitionKnobs[i]);
+ for (VirtualTransitionKnob knob : glucose.transitionKnobs) {
+ drawKnob(xPos, yPos, knobSize, knob);
xPos += knobSize + knobSpacing;
}
yPos += knobSize + knobLabelHeight;
yPos += controlSpacing;
firstEffectKnobY = yPos;
xPos = leftTextPos;
- for (int i = 0; i < effectKnobs.length; ++i) {
- drawKnob(xPos, yPos, knobSize, effectKnobs[i]);
+ for (VirtualEffectKnob knob : glucose.effectKnobs) {
+ drawKnob(xPos, yPos, knobSize, knob);
xPos += knobSize + knobSpacing;
}
yPos += knobSize + knobLabelHeight;
public int getState(LXEffect e) {
if (e.isEnabled()) {
return STATE_PENDING;
- } else if (effects[activeEffectIndex] == e) {
+ } else if (e == glucose.getSelectedEffect()) {
return STATE_ACTIVE;
}
return STATE_DEFAULT;
public int getState(LXTransition t) {
if (t == lx.getTransition()) {
return STATE_PENDING;
- } else if (t == transitions[activeTransitionIndex]) {
+ } else if (t == glucose.getSelectedTransition()) {
return STATE_ACTIVE;
}
return STATE_DEFAULT;
textFont(knobFont);
text(knobLabel, xPos + knobSize/2, yPos + knobSize + knobLabelHeight - 2);
}
-
- class VirtualPatternKnob extends LXVirtualParameter {
- private final int index;
-
- VirtualPatternKnob(int index) {
- this.index = index;
- }
-
- public LXParameter getRealParameter() {
- List<LXParameter> parameters = glucose.getPattern().getParameters();
- if (index < parameters.size()) {
- return parameters.get(index);
- }
- return null;
- }
- }
-
- class VirtualTransitionKnob extends LXVirtualParameter {
- private final int index;
-
- VirtualTransitionKnob(int index) {
- this.index = index;
- }
-
- public LXParameter getRealParameter() {
- List<LXParameter> parameters = transitions[activeTransitionIndex].getParameters();
- if (index < parameters.size()) {
- return parameters.get(index);
- }
- return null;
- }
- }
-
- class VirtualEffectKnob extends LXVirtualParameter {
- private final int index;
-
- VirtualEffectKnob(int index) {
- this.index = index;
- }
-
- public LXParameter getRealParameter() {
- List<LXParameter> parameters = effects[activeEffectIndex].getParameters();
- if (index < parameters.size()) {
- return parameters.get(index);
- }
- return null;
- }
- }
private int patternKnobIndex = -1;
private int transitionKnobIndex = -1;
private int effectKnobIndex = -1;
+ private boolean patternScrolling = false;
private int lastY;
private int releaseEffect = -1;
lastY = mouseY;
patternKnobIndex = transitionKnobIndex = effectKnobIndex = -1;
releaseEffect = -1;
+ patternScrolling = false;
if (mouseY > tempoY) {
if (mouseY - tempoY < tempoHeight) {
lx.tempo.tap();
} else if (mouseY > firstEffectY) {
int effectIndex = objectClickIndex(firstEffectY);
if (effectIndex < effects.length) {
- if (activeEffectIndex == effectIndex) {
+ if (effects[effectIndex] == glucose.getSelectedEffect()) {
effects[effectIndex].enable();
releaseEffect = effectIndex;
}
- activeEffectIndex = effectIndex;
+ glucose.setSelectedEffect(effectIndex);
}
} else if ((mouseY >= firstTransitionKnobY) && (mouseY < firstTransitionKnobY + knobSize + knobLabelHeight)) {
transitionKnobIndex = (mouseX - leftTextPos) / (knobSize + knobSpacing);
} else if (mouseY > firstTransitionY) {
int transitionIndex = objectClickIndex(firstTransitionY);
if (transitionIndex < transitions.length) {
- activeTransitionIndex = transitionIndex;
+ glucose.setSelectedTransition(transitionIndex);
}
} else if ((mouseY >= firstPatternKnobY) && (mouseY < firstPatternKnobY + 2*(knobSize+knobLabelHeight) + knobSpacing)) {
patternKnobIndex = (mouseX - leftTextPos) / (knobSize + knobSpacing);
if (mouseY >= firstPatternKnobY + knobSize + knobLabelHeight + knobSpacing) {
- patternKnobIndex += NUM_PATTERN_KNOBS / 2;
+ patternKnobIndex += glucose.NUM_PATTERN_KNOBS / 2;
}
} else if (mouseY > firstPatternY) {
- int patternIndex = objectClickIndex(firstPatternY);
- if (patternIndex < patterns.length) {
- patterns[patternIndex].setTransition(transitions[activeTransitionIndex]);
- lx.goIndex(patternIndex);
+ if ((patterns.length > PATTERN_LIST_LENGTH) && (mouseX > width - scrollWidth)) {
+ patternScrolling = true;
+ } else {
+ int patternIndex = objectClickIndex(firstPatternY);
+ if (patternIndex < patterns.length) {
+ lx.goIndex(patternIndex + patternScrollPos);
+ }
}
}
}
+ int scrolldy = 0;
public void mouseDragged() {
int dy = lastY - mouseY;
+ scrolldy += dy;
lastY = mouseY;
- if (patternKnobIndex >= 0 && patternKnobIndex < NUM_PATTERN_KNOBS) {
- LXParameter p = patternKnobs[patternKnobIndex];
+ if (patternKnobIndex >= 0 && patternKnobIndex < glucose.NUM_PATTERN_KNOBS) {
+ LXParameter p = glucose.patternKnobs.get(patternKnobIndex);
p.setValue(constrain(p.getValuef() + dy*.01, 0, 1));
- } else if (effectKnobIndex >= 0 && effectKnobIndex < NUM_EFFECT_KNOBS) {
- LXParameter p = effectKnobs[effectKnobIndex];
+ } else if (effectKnobIndex >= 0 && effectKnobIndex < glucose.NUM_EFFECT_KNOBS) {
+ LXParameter p = glucose.effectKnobs.get(effectKnobIndex);
p.setValue(constrain(p.getValuef() + dy*.01, 0, 1));
- } else if (transitionKnobIndex >= 0 && transitionKnobIndex < NUM_TRANSITION_KNOBS) {
- LXParameter p = transitionKnobs[transitionKnobIndex];
+ } else if (transitionKnobIndex >= 0 && transitionKnobIndex < glucose.NUM_TRANSITION_KNOBS) {
+ LXParameter p = glucose.transitionKnobs.get(transitionKnobIndex);
p.setValue(constrain(p.getValuef() + dy*.01, 0, 1));
+ } else if (patternScrolling) {
+ int scroll = scrolldy / lineHeight;
+ scrolldy = scrolldy % lineHeight;
+ patternScrollPos = constrain(patternScrollPos - scroll, 0, patterns.length - PATTERN_LIST_LENGTH);
}
}
public void mouseReleased() {
+ patternScrolling = false;
tempoDown = false;
if (releaseEffect >= 0) {
effects[releaseEffect].trigger();
}
}
+ public void mouseWheel(int delta) {
+ if (mouseY > firstPatternY) {
+ int patternIndex = objectClickIndex(firstPatternY);
+ if (patternIndex < PATTERN_LIST_LENGTH) {
+ patternScrollPos = constrain(patternScrollPos + delta, 0, patterns.length - PATTERN_LIST_LENGTH);
+ }
+ }
+ }
+
}
/**
}
}
- public void mouseReleased() {
- }
+ public void mouseReleased() {}
+ public void mouseWheel(int delta) {}
public void mouseDragged() {
final int DRAG_THRESHOLD = 5;
}
}
-
-
}
-void mousePressed() {
- if (mouseX > ui.leftPos) {
- ui.mousePressed();
- }
-}
-
-void mouseReleased() {
- if (mouseX > ui.leftPos) {
- ui.mouseReleased();
+class DebugUI {
+
+ final int[][] channelList;
+ final int debugX = 10;
+ final int debugY = 42;
+ final int debugXSpacing = 28;
+ final int debugYSpacing = 22;
+ final int[][] debugState = new int[17][6];
+
+ final int DEBUG_STATE_ANIM = 0;
+ final int DEBUG_STATE_WHITE = 1;
+ final int DEBUG_STATE_OFF = 2;
+
+ DebugUI(int[][] frontChannels, int[][] rearChannels) {
+ channelList = new int[frontChannels.length + rearChannels.length][];
+ int channelIndex = 0;
+ for (int[] channel : frontChannels) {
+ channelList[channelIndex++] = channel;
+ }
+ for (int[] channel : rearChannels) {
+ channelList[channelIndex++] = channel;
+ }
+ for (int i = 0; i < debugState.length; ++i) {
+ for (int j = 0; j < debugState[i].length; ++j) {
+ debugState[i][j] = DEBUG_STATE_ANIM;
+ }
+ }
}
-}
-
-void mouseDragged() {
- if (mouseX > ui.leftPos) {
- ui.mouseDragged();
+
+ void draw() {
+ noStroke();
+ int xBase = debugX;
+ int yPos = debugY;
+
+ fill(color(0, 0, 0, 80));
+ rect(4, 32, 172, 388);
+
+ int channelNum = 0;
+ for (int[] channel : channelList) {
+ int xPos = xBase;
+ drawNumBox(xPos, yPos, channelNum+1, debugState[channelNum][0]);
+
+ boolean first = true;
+ int cubeNum = 0;
+ for (int cube : channel) {
+ if (cube == 0) {
+ break;
+ }
+ xPos += debugXSpacing;
+ if (first) {
+ first = false;
+ } else {
+ stroke(#999999);
+ line(xPos - 12, yPos + 8, xPos, yPos + 8);
+ }
+ drawNumBox(xPos, yPos, cube, debugState[channelNum][cubeNum+1]);
+ ++cubeNum;
+ }
+
+ yPos += debugYSpacing;
+ ++channelNum;
+ }
+ drawNumBox(xBase, yPos, "A", debugState[channelNum][0]);
+ }
+
+ void drawNumBox(int xPos, int yPos, int label, int state) {
+ drawNumBox(xPos, yPos, "" + label, state);
+ }
+
+ void drawNumBox(int xPos, int yPos, String label, int state) {
+ noFill();
+ color textColor = #cccccc;
+ switch (state) {
+ case DEBUG_STATE_ANIM:
+ noStroke();
+ fill(#880000);
+ rect(xPos, yPos, 16, 8);
+ fill(#000088);
+ rect(xPos, yPos+8, 16, 8);
+ noFill();
+ stroke(textColor);
+ rect(xPos, yPos, 16, 16);
+ break;
+ case DEBUG_STATE_WHITE:
+ stroke(textColor);
+ fill(#e9e9e9);
+ rect(xPos, yPos, 16, 16);
+ textColor = #333333;
+ break;
+ case DEBUG_STATE_OFF:
+ stroke(textColor);
+ rect(xPos, yPos, 16, 16);
+ break;
+ }
+
+ noStroke();
+ fill(textColor);
+ text(label, xPos + 2, yPos + 12);
+
+ }
+
+ void maskColors(color[] colors) {
+ color white = #FFFFFF;
+ color off = #000000;
+ int channelIndex = 0;
+ for (int[] channel : channelList) {
+ int cubeIndex = 1;
+ for (int rawCubeIndex : channel) {
+ if (rawCubeIndex > 0) {
+ int state = debugState[channelIndex][cubeIndex];
+ if (state != DEBUG_STATE_ANIM) {
+ color debugColor = (state == DEBUG_STATE_WHITE) ? white : off;
+ Cube cube = glucose.model.getCubeByRawIndex(rawCubeIndex);
+ for (Point p : cube.points) {
+ colors[p.index] = debugColor;
+ }
+ }
+ }
+ ++cubeIndex;
+ }
+ ++channelIndex;
+ }
}
+
+ void mousePressed() {
+ int dx = (mouseX - debugX) / debugXSpacing;
+ int dy = (mouseY - debugY) / debugYSpacing;
+ if ((dy >= 0) && (dy < debugState.length)) {
+ if ((dx >= 0) && (dx < debugState[dy].length)) {
+ int newState = debugState[dy][dx] = (debugState[dy][dx] + 1) % 3;
+ if (dy == 16) {
+ for (int[] states : debugState) {
+ for (int i = 0; i < states.length; ++i) {
+ states[i] = newState;
+ }
+ }
+ } else if (dx == 0) {
+ for (int i = 0; i < debugState[dy].length; ++i) {
+ debugState[dy][i] = newState;
+ }
+ }
+ }
+ }
+ }
}
-