midiControllers.add(new APC40MidiInput(this, device, apcDeck).setEnabled(true));
} else if (device.getName().contains("SLIDER/KNOB KORG")) {
midiControllers.add(new KorgNanoKontrolMidiInput(this, device).setEnabled(true));
+ } else if (device.getName().contains("Arturia MINILAB")) {
+ midiControllers.add(new ArturiaMinilabMidiInput(this, device).setEnabled(true));
} else {
- boolean enabled = device.getName().contains("KEYBOARD KORG") || device.getName().contains("Bus 1 Apple");
+ boolean enabled =
+ device.getName().contains("KEYBOARD KORG") ||
+ device.getName().contains("Bus 1 Apple");
midiControllers.add(new GenericDeviceMidiInput(this, device).setEnabled(enabled));
}
}
return this.midiControllers;
}
- public Engine.Deck getFocusedDeck() {
+ public LXDeck getFocusedDeck() {
return lx.engine.getDeck(activeDeckIndex);
}
if (logMidi()) {
println(getLabel() + " :: Controller :: " + cc.getChannel() + " :: " + cc.getCC() + ":" + cc.getValue());
}
- if (!handleGridControllerChange(cc)) {
- if (!getTargetPattern().controllerChange(cc)) {
- handleControllerChange(cc);
- }
+ if (!handleControllerChange(cc)) {
+ getTargetPattern().controllerChange(cc);
}
}
if (logMidi()) {
println(getLabel() + " :: Note On :: " + note.getChannel() + ":" + note.getPitch() + ":" + note.getVelocity());
}
- if (!handleGridNoteOn(note)) {
- if (!getTargetPattern().noteOn(note)) {
- handleNoteOn(note);
- }
+ if (!handleNoteOn(note)) {
+ getTargetPattern().noteOn(note);
}
}
if (logMidi()) {
println(getLabel() + " :: Note Off :: " + note.getChannel() + ":" + note.getPitch() + ":" + note.getVelocity());
}
- if (!handleGridNoteOff(note)) {
- if (!getTargetPattern().noteOff(note)) {
- handleNoteOff(note);
+ if (!handleNoteOff(note)) {
+ getTargetPattern().noteOff(note);
+ }
+ }
+
+ protected void setNormalized(LXParameter parameter, float value) {
+ if (parameter != null) {
+ if (parameter instanceof BasicParameter) {
+ ((BasicParameter)parameter).setNormalized(value);
+ } else {
+ parameter.setValue(value);
}
}
}
// Subclasses may implement these to map top-level functionality
- protected boolean handleGridNoteOn(Note note) { return false; }
- protected boolean handleGridNoteOff(Note note) { return false; }
- protected boolean handleGridControllerChange(rwmidi.Controller cc) { return false; }
- protected void handleProgramChange(ProgramChange pc) {}
- protected void handleControllerChange(rwmidi.Controller cc) {}
- protected void handleNoteOn(Note note) {}
- protected void handleNoteOff(Note note) {}
+ protected boolean handleProgramChange(ProgramChange pc) { return false; }
+ protected boolean handleControllerChange(rwmidi.Controller cc) { return false; }
+ protected boolean handleNoteOn(Note note) { return false; }
+ protected boolean handleNoteOff(Note note) { return false; }
}
public class VirtualKeyMidiInput extends SCMidiInput {
private boolean shiftOn = false;
private LXEffect releaseEffect = null;
- final private Engine.Deck targetDeck;
+ final private LXDeck targetDeck;
APC40MidiInput(MidiEngine midiEngine, MidiInputDevice d) {
this(midiEngine, d, -1);
targetDeck = (deckIndex < 0) ? null : lx.engine.getDecks().get(deckIndex);
}
- protected Engine.Deck getTargetDeck() {
- if (targetDeck != null) {
- return targetDeck;
- }
- return midiEngine.getFocusedDeck();
+ protected LXDeck getTargetDeck() {
+ return (targetDeck != null) ? targetDeck : midiEngine.getFocusedDeck();
}
protected SCPattern getTargetPattern() {
return null;
}
- protected boolean handleGridNoteOn(Note note) {
+ private boolean handleGridNoteOn(Note note) {
GridPosition p = getGridPosition(note);
if (p != null) {
return midiEngine.grid.gridPressed(p.row, p.col);
return false;
}
- protected boolean handleGridNoteOff(Note note) {
+ private boolean handleGridNoteOff(Note note) {
GridPosition p = getGridPosition(note);
if (p != null) {
return midiEngine.grid.gridReleased(p.row, p.col);
return false;
}
- protected void handleControllerChange(rwmidi.Controller cc) {
+ protected boolean handleControllerChange(rwmidi.Controller cc) {
int channel = cc.getChannel();
int number = cc.getCC();
float value = cc.getValue() / 127.;
case 7:
switch (channel) {
case 0:
- EFF_colorFucker.hueShift.setValue(value);
- break;
+ uiSpeed.speed.setNormalized(0.5 - value*0.5);
+ return true;
case 1:
- EFF_colorFucker.desat.setValue(value);
- break;
+ effects.colorFucker.desat.setNormalized(value);
+ return true;
case 2:
- EFF_colorFucker.sharp.setValue(value);
- break;
+ effects.colorFucker.desat.setNormalized(value);
+ return true;
case 3:
- EFF_blur.amount.setValue(value);
- break;
+ effects.blur.amount.setNormalized(value);
+ return true;
case 4:
- EFF_quantize.amount.setValue(value);
- break;
+ effects.quantize.amount.setNormalized(value);
+ return true;
}
break;
// Master bright
case 14:
- EFF_colorFucker.level.setValue(value);
- break;
+ effects.colorFucker.level.setNormalized(value);
+ return true;
// Crossfader
case 15:
- lx.engine.getDeck(1).getCrossfader().setValue(value);
- break;
+ lx.engine.getDeck(GLucose.RIGHT_DECK).getFader().setNormalized(value);
+ return true;
+
+ // Cue level
+ case 47:
+ float val = effects.colorFucker.hueShift.getValuef();
+ int cv = cc.getValue();
+ if (cv < 64) {
+ cv = 64 + cv;
+ } else {
+ cv = cv - 64;
+ }
+ val += (cv - 64) / 500.;
+ effects.colorFucker.hueShift.setNormalized((val+1) % 1);
+ return true;
}
int parameterIndex = -1;
if (parameterIndex >= 0) {
List<LXParameter> parameters = getTargetPattern().getParameters();
if (parameterIndex < parameters.size()) {
- parameters.get(parameterIndex).setValue(value);
+ setNormalized(parameters.get(parameterIndex), value);
+ return true;
}
}
int effectIndex = number - 20;
List<LXParameter> parameters = glucose.getSelectedEffect().getParameters();
if (effectIndex < parameters.size()) {
- parameters.get(effectIndex).setValue(value);
+ setNormalized(parameters.get(effectIndex), value);
+ return true;
}
}
+
+ return false;
}
private long tap1 = 0;
return a >= b && a <= c;
}
- protected void handleNoteOn(Note note) {
+ protected boolean handleNoteOn(Note note) {
+ if (handleGridNoteOn(note)) {
+ return true;
+ }
+
int nPitch = note.getPitch();
int nChan = note.getChannel();
switch (nPitch) {
case 49: // SOLO/CUE
switch (nChan) {
case 4:
- EFF_colorFucker.mono.setValue(1);
- break;
+ effects.colorFucker.mono.setNormalized(1);
+ return true;
case 5:
- EFF_colorFucker.invert.setValue(1);
- break;
+ effects.colorFucker.invert.setNormalized(1);
+ return true;
case 6:
lx.cycleBaseHue(60000);
- break;
+ return true;
}
break;
case 82: // scene 1
- EFF_boom.trigger();
- break;
+ effects.boom.trigger();
+ return true;
case 83: // scene 2
- EFF_flash.trigger();
- break;
+ effects.flash.trigger();
+ return true;
+
+ case 84: // scene 3
+ getTargetPattern().reset();
+ return true;
case 90:
// dan's dirty tapping mechanism
lx.tempo.trigger();
tap1 = millis();
- break;
+ return true;
case 91: // play
- case 97: // left bank
- midiEngine.setFocusedDeck(0);
- break;
-
+ if (shiftOn) {
+ midiEngine.setFocusedDeck(GLucose.LEFT_DECK);
+ } else {
+ uiCrossfader.setDisplayMode("A");
+ }
+ return true;
+
+ case 92: // stop
+ uiCrossfader.setDisplayMode("COMP");
+ return true;
+
case 93: // rec
- case 96: // right bank
- midiEngine.setFocusedDeck(1);
- break;
+ if (shiftOn) {
+ midiEngine.setFocusedDeck(GLucose.RIGHT_DECK);
+ } else {
+ uiCrossfader.setDisplayMode("B");
+ }
+ return true;
case 94: // up bank
if (shiftOn) {
} else {
getTargetDeck().goPrev();
}
- break;
+ return true;
+
case 95: // down bank
if (shiftOn) {
glucose.incrementSelectedEffectBy(1);
} else {
getTargetDeck().goNext();
}
- break;
+ return true;
case 98: // shift
shiftOn = true;
- break;
+ return true;
case 99: // tap tempo
lx.tempo.tap();
- break;
+ return true;
+
case 100: // nudge+
lx.tempo.setBpm(lx.tempo.bpm() + (shiftOn ? 1 : .1));
- break;
+ return true;
+
case 101: // nudge-
lx.tempo.setBpm(lx.tempo.bpm() - (shiftOn ? 1 : .1));
- break;
+ return true;
case 62: // Detail View / red 5
releaseEffect = glucose.getSelectedEffect();
} else {
releaseEffect.toggle();
}
- break;
+ return true;
case 63: // rec quantize / red 6
glucose.getSelectedEffect().disable();
- break;
+ return true;
}
+
+ return false;
}
- protected void handleNoteOff(Note note) {
+ protected boolean handleNoteOff(Note note) {
+ if (handleGridNoteOff(note)) {
+ return true;
+ }
+
int nPitch = note.getPitch();
int nChan = note.getChannel();
case 49: // SOLO/CUE
switch (nChan) {
case 4:
- EFF_colorFucker.mono.setValue(0);
- break;
+ effects.colorFucker.mono.setNormalized(0);
+ return true;
case 5:
- EFF_colorFucker.invert.setValue(0);
- break;
+ effects.colorFucker.invert.setNormalized(0);
+ return true;
case 6:
lx.setBaseHue(lx.getBaseHue());
- break;
+ return true;
}
break;
presetManager.select(getTargetDeck(), nChan);
}
}
- break;
+ return true;
case 90: // SEND C
long tapDelta = millis() - tap1;
tap1 = 0;
println("Tap Set - " + bpm + " bpm");
}
- break;
+ return true;
case 63: // rec quantize / RED 6
if (releaseEffect != null) {
releaseEffect.disable();
}
}
- break;
+ return true;
case 98: // shift
shiftOn = false;
- break;
+ return true;
}
+
+ return false;
}
}
super(midiEngine, d);
}
- protected void handleControllerChange(rwmidi.Controller cc) {
+ protected boolean handleControllerChange(rwmidi.Controller cc) {
int number = cc.getCC();
if (number >= 16 && number <= 23) {
int parameterIndex = number - 16;
List<LXParameter> parameters = midiEngine.getFocusedPattern().getParameters();
if (parameterIndex < parameters.size()) {
- parameters.get(parameterIndex).setValue(cc.getValue() / 127.);
+ setNormalized(parameters.get(parameterIndex), cc.getValue() / 127.);
+ return true;
}
}
if (cc.getValue() == 127) {
switch (number) {
- // Left track
- case 58:
- midiEngine.setFocusedDeck(0);
- break;
- // Right track
- case 59:
- midiEngine.setFocusedDeck(1);
- break;
- // Left chevron
- case 43:
+
+ case 58: // Left track
+ midiEngine.setFocusedDeck(GLucose.LEFT_DECK);
+ return true;
+
+ case 59: // Right track
+ midiEngine.setFocusedDeck(GLucose.RIGHT_DECK);
+ return true;
+
+ case 43: // Left chevron
midiEngine.getFocusedDeck().goPrev();
- break;
- // Right chevron
- case 44:
+ return true;
+
+ case 44: // Right chevron
midiEngine.getFocusedDeck().goNext();
- break;
+ return true;
}
}
+
+ return false;
}
}
-class APC40MidiOutput implements LXParameter.Listener, GridOutput {
+class APC40MidiOutput implements LXParameterListener, GridOutput {
private final MidiEngine midiEngine;
private final MidiOutput output;
private LXPattern focusedPattern = null;
private LXEffect focusedEffect = null;
- private final Engine.Deck targetDeck;
+ private final LXDeck targetDeck;
APC40MidiOutput(MidiEngine midiEngine, MidiOutputDevice device) {
this(midiEngine, device, -1);
midiEngine.addListener(new MidiEngineListener() {
public void onFocusedDeck(int deckIndex) {
resetPatternParameters();
+ for (int i = 0; i < 8; ++i) {
+ output.sendNoteOn(i, 52, 0);
+ }
}
});
}
resetEffectParameters();
}
});
- Engine.Listener deckListener = new Engine.AbstractListener() {
- public void patternDidChange(Engine.Deck deck, LXPattern pattern) {
- resetPatternParameters();
+ LXDeck.Listener deckListener = new LXDeck.AbstractListener() {
+ public void patternDidChange(LXDeck deck, LXPattern pattern) {
+ if (deck == getTargetDeck()) {
+ resetPatternParameters();
+ }
}
};
- for (Engine.Deck d : lx.engine.getDecks()) {
+ for (LXDeck d : lx.engine.getDecks()) {
if (targetDeck == null || d == targetDeck) {
d.addListener(deckListener);
}
}
presetManager.addListener(new PresetListener() {
- public void onPresetLoaded(Preset preset) {
- for (int i = 0; i < 8; ++i) {
- output.sendNoteOn(i, 52, (preset.index == i) ? 1 : 0);
+ public void onPresetSelected(LXDeck deck, Preset preset) {
+ if (deck == getTargetDeck()) {
+ for (int i = 0; i < 8; ++i) {
+ output.sendNoteOn(i, 52, (preset.index == i) ? 1 : 0);
+ }
}
}
- public void onPresetDirty(Preset preset) {
- output.sendNoteOn(preset.index, 52, 2);
- }
- public void onPresetStored(Preset preset) {
- onPresetLoaded(preset);
- }
- public void onPresetUnloaded() {
- for (int i = 0; i < 8; ++i) {
- output.sendNoteOn(i, 52, 0);
+ public void onPresetDirty(LXDeck deck, Preset preset) {
+ if (deck == getTargetDeck()) {
+ output.sendNoteOn(preset.index, 52, 2);
}
}
+ public void onPresetStored(LXDeck deck, Preset preset) {
+ onPresetSelected(deck, preset);
+ }
});
resetParameters();
midiEngine.grid.addOutput(this);
}
private void setDPatternOutputs() {
- for (Engine.Deck deck : lx.engine.getDecks()) {
+ for (LXDeck deck : lx.engine.getDecks()) {
if (targetDeck == null || deck == targetDeck) {
for (LXPattern pattern : deck.getPatterns()) {
if (pattern instanceof DPat) {
}
}
- protected Engine.Deck getTargetDeck() {
- if (targetDeck != null) {
- return targetDeck;
- }
- return midiEngine.getFocusedDeck();
+ protected LXDeck getTargetDeck() {
+ return (targetDeck != null) ? targetDeck : midiEngine.getFocusedDeck();
}
private void resetParameters() {
}
}
+class ArturiaMinilabMidiInput extends GenericDeviceMidiInput {
+ ArturiaMinilabMidiInput(MidiEngine midiEngine, MidiInputDevice d) {
+ super(midiEngine, d);
+ }
+
+ protected boolean handleControllerChange(rwmidi.Controller cc) {
+ int parameterIndex = -1;
+ switch (cc.getCC()) {
+ case 7: parameterIndex = 0; break;
+ case 74: parameterIndex = 1; break;
+ case 71: parameterIndex = 2; break;
+ case 76: parameterIndex = 3; break;
+ case 114: parameterIndex = 4; break;
+ case 18: parameterIndex = 5; break;
+ case 19: parameterIndex = 6; break;
+ case 16: parameterIndex = 7; break;
+
+ case 75:
+ float val = effects.colorFucker.hueShift.getValuef();
+ val += (cc.getValue() - 64) / 256.;
+ effects.colorFucker.hueShift.setNormalized((val+1) % 1);
+ break;
+ }
+ if (parameterIndex >= 0) {
+ List<LXParameter> parameters = midiEngine.getFocusedPattern().getParameters();
+ if (parameterIndex < parameters.size()) {
+ LXParameter p = parameters.get(parameterIndex);
+ float curVal = p.getValuef();
+ curVal += (cc.getValue() - 64) / 127.;
+ setNormalized(p, constrain(curVal, 0, 1));
+ }
+ }
+ return false;
+ }
+}
+
interface GridOutput {
public static final int OFF = 0;
public static final int GREEN = 1;
repositories / SugarCubes.git / blobdiff