Gordonjcp/chassis
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

start work on proper assigner for chassis based on real one

Browse Source
This commit is contained in:
Gordon JC Pearce 2024-09-19 22:33:25 +01:00
parent 1303d77f5b
commit 0805abdf8e
6 changed files with 2998 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
plugin/chassis.cpp
View File

@ -69,56 +69,11 @@ void Chassis::deactivate() {
void Chassis::noteOn(uint8_t note) {
uint32_t i;
//ic1.ram[0x4e] = 0x90;
//ic1.ram[0x3e] = note;
// ic1.noteOn(0x40);
#ifdef D_MIDIBITMAP
printf("note on -> ");
for (uint8_t i = 0x40; i < 0x4f; i++) {
printf("%02x ", ic1.ram[i]);
}
printf("\n");
#endif
s.keyon = true;
for (i = 0; i < NUM_VOICES; i++) {
vPtr++;
if (vPtr == NUM_VOICES) vPtr = 0;
if (s.voice[vPtr].isFree()) {
// if it's an existing note don't reset
s.voice[vPtr].on(note, s.voice[i].note != note);
break;
}
}
if (i == NUM_VOICES) { // didn't find a free voice
vPtr++;
if (vPtr == NUM_VOICES) vPtr = 0;
s.voice[vPtr].on(note, true);
}
}
void Chassis::noteOff(uint8_t note) {
//ic1.ram[0x4e] = 0x90;
//ic1.ram[0x3e] = note;
//ic1.noteOn(0);
#ifdef D_MIDIBITMAP
printf("note off -> ");
for (uint8_t i = 0x40; i < 0x4f; i++) {
printf("%02x ", ic1.ram[i]);
}
printf("\n");
#endif
s.keyon = false;
for (uint32_t i = 0; i < NUM_VOICES; i++) {
if (s.voice[i].note == note && !s.voice[i].isFree()) {
s.voice[i].off();
break;
}
}
}
void Chassis::doMidi(const MidiEvent *ev, uint32_t count, uint32_t timeLimit) {

4
plugin/chassis.hpp
View File

@ -61,6 +61,10 @@ class Chassis : public Plugin {
paramSustain,
paramRelease,
paramChorusMode,
paramPolyMode,
paramModWheel,
parameterCount

306
plugin/ic1.cpp
View File

@ -146,7 +146,7 @@
// 00fd: 78 43 CALF $0843_sendOmniOffPoly
// 00ff: 71 ba 20 MVIW $FFBA_bank,$20
// 0102: 71 bb 01 MVIW $FFBB_patch,$01
// 0105: 58 b6 BIT 0,$FFB6 // test mode?
// 0105: 58 b6 BIT 0,$FFB6 // test mode? // test mode?
// 0107: 71 ba 10 MVIW $FFBA_bank,$10 // if not, set bank
// 010a: 71 be 0c MVIW $FFBE_transpose,$0C // default transpose is 12
// 010d: 7b 9a CALF $0B9A_clrMidiBits //
@ -322,7 +322,7 @@
// 0226: 42 INR B // next column
// 0227: 48 0b SK HC // did it roll over nybble
// 0229: e6 JR $0210 // no, loop back for next
// 022a: 58 b6 BIT 0,$FFB6 // test mode?
// 022a: 58 b6 BIT 0,$FFB6 // test mode? // test mode?
// 022c: c2 JR $022F // no
// 022d: 4e 3f JRE $026E // interpret buttons for test mode
// 022f: 5b ae BIT 3,$FFAE // has the MIDI Channel button changed?
@ -414,7 +414,7 @@
// 02d0: 01 c8 LDAW $FFC8_ledCol3
// 02d2: 16 c0 XRI A,$C0 // toggle Group A/B LEDs
// 02d4: 63 c8 STAW $FFC8_ledCol3 // save it back
// 02d6: 58 b6 BIT 0,$FFB6 // group button?
// 02d6: 58 b6 BIT 0,$FFB6 // test mode? // group button?
// 02d8: cc JR $02E5 // not pressed
// 02d9: 69 fd MVI A,$FD // select module board
// 02db: 79 e8 CALF $09E8_sendToTx
@ -719,10 +719,10 @@
// 0526: 71 b7 00 MVIW $FFB7,$00
// 0529: 01 8f LDAW $FF8F_switches2
// 052b: 7c 29 CALF $0C29
// 052d: 58 b6 BIT 0,$FFB6
// 052d: 58 b6 BIT 0,$FFB6 // test mode?
// 052f: 54 11 01 JMP $0111
// 0532: 6a 05 MVI B,$05
// 0534: 34 8d ff LXI HL,$FF8D
// 0534: 34 8d ff LXI HL,$FF8D_noteTbl+5
// 0537: 2f LDAX (HL-)
// 0538: 47 80 ONI A,$80
// 053a: c5 JR $0540
@ -1498,8 +1498,10 @@
// 0a0b: a3 POP HL
// 0a0c: b8 RET
// a / 8 into EAH, C back into A, store C at $FFC3
// to do with note on flags
// set up to calculate note from bitfield
// given one bit from the key on bitfield, use the column *8
// which ends up in EAH and C (the original bitfield) ends up
// in FFC3 where it's XORed to see if a note has changed
// 0a0d: 48 25 SLL A
// 0a0f: 48 25 SLL A
// 0a11: 48 25 SLL A
@ -1508,83 +1510,102 @@
// 0a15: 63 c3 STAW $FFC3
// 0a17: b8 RET
// voice functions?
// 0a18: 19 MOV EAL,A
// voice on/off to module board
// when we enter here A contains the "changed" bits
// found by XORing the "calculated" bitfield with
// the "stored" bitfield
// 0a18: 19 MOV EAL,A // save
// 0a19: 0a MOV A,B
// 0a1a: 7a 0d CALF $0A0D
// 0a1a: 7a 0d CALF $0A0D // construct note from B and C
// 0a1c: b3 PUSH HL
// 0a1d: b1 PUSH BC
// 0a1e: 6a 07 MVI B,$07
// 0a20: 09 MOV A,EAL
// 0a1e: 6a 07 MVI B,$07 // 8 bits
// 0a20: 09 MOV A,EAL // note bitfield
// 0a21: 1b MOV C,A
// 0a22: 34 08 00 LXI HL,$0008
// 0a25: 48 07 SLLC C
// 0a27: 4e 37 JRE $0A60
// 0a29: ad LDAX (HL+B)
// 0a2a: 74 c8 c3 ONAW $FFC3
// 0a2d: 4e 23 JRE $0A52
// 0a2f: 08 MOV A,EAH
// 0a30: 60 9a ORA A,B
// 0a22: 34 08 00 LXI HL,$0008 // lookup table of bits
// 0a25: 48 07 SLLC C // shift bitfield out
// 0a27: 4e 37 JRE $0A60 // skip this on no carry
// 0a29: ad LDAX (HL+B) // found a bit, look it up in the list
// 0a2a: 74 c8 c3 ONAW $FFC3 // was it already set?
// 0a2d: 4e 23 JRE $0A52 // Yes
// 0a2f: 08 MOV A,EAH // No, note on
// 0a30: 60 9a ORA A,B // combine B with EAH, which holds the upper four bits of note number
// 0a32: 59 c8 BIT 1,$FFC8_ledCol3 // Poly 1
// 0a34: da JR $0A4F
// 0a34: da JR $0A4F // poly 1 not set, jump to poly 2 assigner
// 0a35: 5a c8 BIT 2,$FFC8_ledCol3 // Poly 2
// 0a37: c7 JR $0A3F
// 0a38: 58 b6 BIT 0,$FFB6
// 0a3a: c7 JR $0A42
// 0a3b: 7a 88 CALF $0A88
// 0a3d: 4e 21 JRE $0A60
// 0a3f: 58 b6 BIT 0,$FFB6
// 0a41: ca JR $0A4C
// 0a42: 75 d0 00 EQIW $FFD0,$00
// 0a45: da JR $0A60
// 0a37: c7 JR $0A3F // poly 2 not set, jump to poly 1 assigner
// 0a38: 58 b6 BIT 0,$FFB6 // test mode? // unison mode, get test mode
// 0a3a: c7 JR $0A42 // not test mode, skip
// 0a3b: 7a 88 CALF $0A88 // cycle round voices
// 0a3d: 4e 21 JRE $0A60 // jump on and do next note
// -----------------------------------------------------------
// Poly 1 Note On handler
// -----------------------------------------------------------
// 0a3f: 58 b6 BIT 0,$FFB6 // test mode? // test mode?
// 0a41: ca JR $0A4C // no
// 0a42: 75 d0 00 EQIW $FFD0,$00 // try next note if there's already a note held
// 0a45: da JR $0A60 // do next note
// 0a46: 7b 55 CALF $0B55_noteOnUnison
// 0a48: 71 d0 80 MVIW $FFD0,$80
// 0a4b: d4 JR $0A60
// 0a4c: 7a af CALF $0AAF
// 0a4e: d1 JR $0A60
// 0a4f: 7a 76 CALF $0A76
// 0a51: ce JR $0A60
// 0a48: 71 d0 80 MVIW $FFD0,$80 // set flag for note held
// 0a4b: d4 JR $0A60 // do next note
// 0a4c: 7a af CALF $0AAF // real poly1 assigner
// 0a4e: d1 JR $0A60 // do next note
// -----------------------------------------------------------
// Poly 2 Note On handler
// -----------------------------------------------------------
// 0a4f: 7a 76 CALF $0A76 // real poly 2 assigner works the same in test and normal mode
// 0a51: ce JR $0A60 // do the next note
// -----------------------------------------------------------
// Main Note Off handler
// -----------------------------------------------------------
// 0a52: 08 MOV A,EAH
// 0a53: 60 9a ORA A,B
// 0a53: 60 9a ORA A,B // get true note number
// 0a55: 59 c8 BIT 1,$FFC8_ledCol3 // Poly 1
// 0a57: c6 JR $0A5E
// 0a57: c6 JR $0A5E // no, go to poly2 handler
// 0a58: 5a c8 BIT 2,$FFC8_ledCol3 // Poly 2
// 0a5a: cb JR $0A66
// 0a5b: 58 b6 BIT 0,$FFB6
// 0a5d: cb JR $0A69
// 0a5e: 7b 30 CALF $0B30
// 0a60: 52 DCR B
// 0a61: 4f c2 JRE $0A25
// 0a63: a1 POP BC
// 0a5a: cb JR $0A66 // no, go to poly1 handler
// 0a5b: 58 b6 BIT 0,$FFB6 // test mode?
// 0a5d: cb JR $0A69 // unison handler
// 0a5e: 7b 30 CALF $0B30 // test mode cyclic turn off voices
// -----------------------------------------------------------
// 0a60: 52 DCR B // count down
// 0a61: 4f c2 JRE $0A25 // if there are bits left loop back
// 0a63: a1 POP BC // return
// 0a64: a3 POP HL
// 0a65: b8 RET
// 0a66: 58 b6 BIT 0,$FFB6
// 0a68: ca JR $0A73
// 0a69: 75 d0 00 EQIW $FFD0,$00
// 0a6c: f3 JR $0A60
// -----------------------------------------------------------
// test mode "poly1" note off
// -----------------------------------------------------------
// 0a66: 58 b6 BIT 0,$FFB6 // test mode?
// 0a68: ca JR $0A73 // no
// 0a69: 75 d0 00 EQIW $FFD0,$00 // no note held
// 0a6c: f3 JR $0A60 // next note in byte
// 0a6d: 7b 70 CALF $0B70_stopAllNotes
// 0a6f: 71 d0 ff MVIW $FFD0,$FF
// 0a72: ed JR $0A60
// 0a73: 7a f8 CALF $0AF8
// 0a6f: 71 d0 ff MVIW $FFD0,$FF // this flag
// 0a72: ed JR $0A60 // loop back
// 0a73: 7a f8 CALF $0AF8 // real Poly 1 handler
// 0a75: ea JR $0A60
// -----------------------------------------------------------
// real Poly 2 assigner
// -----------------------------------------------------------
// voice functions
// 0a76: b3 PUSH HL
// 0a77: b1 PUSH BC
// 0a78: 1b MOV C,A
// 0a79: 6a 05 MVI B,$05
// 0a7b: 34 88 ff LXI HL,$FF88
// 0a7e: 2b LDAX (HL)
// 0a7f: 57 80 OFFI A,$80
// 0a81: dc JR $0A9E
// 0a82: 32 INX HL
// 0a83: 52 DCR B
// 0a84: f9 JR $0A7E
// 0a85: a1 POP BC
// 0a77: b1 PUSH BC // save
// 0a78: 1b MOV C,A // changed bit
// 0a79: 6a 05 MVI B,$05 // six voices
// 0a7b: 34 88 ff LXI HL,$FF88_noteTbl // voice table
// 0a7e: 2b LDAX (HL) // get value
// 0a7f: 57 80 OFFI A,$80 // top bit clear
// 0a81: dc JR $0A9E // no, send note to module board
// 0a82: 32 INX HL // next voice
// 0a83: 52 DCR B // count down
// 0a84: f9 JR $0A7E // loop back
// 0a85: a1 POP BC // return
// 0a86: a3 POP HL
// 0a87: b8 RET
// voice functions
// test mode for "Unison", cycle round voices
// 0a88: b3 PUSH HL
// 0a89: b1 PUSH BC
// 0a8a: 6e ff MVI H,$FF
@ -1601,6 +1622,9 @@
// 0a9b: c2 JR $0A9E
// 0a9c: 52 DCR B
// 0a9d: ef JR $0A8D
// -----------------------------------------------------------
// called with note number in L, note to play in C
// -----------------------------------------------------------
// 0a9e: 69 fd MVI A,$FD // select module board
// 0aa0: 79 e8 CALF $09E8_sendToTx
// 0aa2: 0f MOV A,L
@ -1613,82 +1637,86 @@
// 0aad: a3 POP HL
// 0aae: b8 RET
// voice functions
// -----------------------------------------------------------
// real Poly 1 note on assigner
// -----------------------------------------------------------
// 0aaf: b3 PUSH HL
// 0ab0: b1 PUSH BC
// 0ab1: b2 PUSH DE
// 0ab2: 1b MOV C,A
// 0ab3: 6a 05 MVI B,$05
// 0ab5: 6c ff MVI D,$FF
// 0ab7: 34 85 ff LXI HL,$FF85
// 0aba: 2b LDAX (HL)
// 0abb: 1d MOV E,A
// 0abc: 2a LDAX (DE)
// 0abd: 57 80 OFFI A,$80
// 0abf: ca JR $0ACA
// 0ac0: a2 POP DE
// 0ab2: 1b MOV C,A // save all registers including A
// 0ab3: 6a 05 MVI B,$05 // six voices
// 0ab5: 6c ff MVI D,$FF // upper byte of pointer
// 0ab7: 34 85 ff LXI HL,$FF80_voiceTbl+5
// 0aba: 2b LDAX (HL) // get voice
// 0abb: 1d MOV E,A // save
// 0abc: 2a LDAX (DE) // get value pointed to from note table
// 0abd: 57 80 OFFI A,$80 // bit7?
// 0abf: ca JR $0ACA // is set
// 0ac0: a2 POP DE // return, is this "all notes used?"
// 0ac1: a1 POP BC
// 0ac2: a3 POP HL
// 0ac3: b8 RET
// 0ac4: 2b LDAX (HL)
// 0ac5: 1d MOV E,A
// 0ac6: 2a LDAX (DE)
// 0ac7: 47 80 ONI A,$80
// 0ac9: c8 JR $0AD2
// 0aca: 07 7f ANI A,$7F
// 0acc: 60 eb NEA A,C
// 0ace: d1 JR $0AE0
// 0acf: 33 DCX HL
// 0ad0: 52 DCR B
// 0ad1: f2 JR $0AC4
// 0ad2: 32 INX HL
// 0ad3: 2b LDAX (HL)
// 0ad4: 1d MOV E,A
// 0ad5: 0b MOV A,C
// 0ad6: ce JR $0AE5
// 0ad7: 33 DCX HL
// 0ad8: af 01 LDAX (HL+$01)
// 0ada: 1b MOV C,A
// 0adb: 2b LDAX (HL)
// 0adc: bf 01 STAX (HL+$01)
// 0ade: 0b MOV A,C
// 0adf: 3b STAX (HL)
// 0ae0: 52 DCR B
// 0ae1: f5 JR $0AD7
// 0ae2: 2a LDAX (DE)
// 0ae3: 07 7f ANI A,$7F
// 0ae5: 3a STAX (DE)
// 0ae6: 74 c0 be ADDW $FFBE_transpose
// 0ae9: 1b MOV C,A
// 0ac4: 2b LDAX (HL) // fetch next voice
// 0ac5: 1d MOV E,A // form address
// 0ac6: 2a LDAX (DE) // fetch note number
// 0ac7: 47 80 ONI A,$80 // test if top bit is set
// 0ac9: c8 JR $0AD2 // no, jump to tried all voices?
// 0aca: 07 7f ANI A,$7F // mask off top bit
// 0acc: 60 eb NEA A,C // is this the note we're already playing
// 0ace: d1 JR $0AE0 // not equal, go ahead
// 0acf: 33 DCX HL // count down a voice
// 0ad0: 52 DCR B // one less to try
// 0ad1: f2 JR $0AC4 // loop back around to slightly before the beginning
// 0ad2: 32 INX HL // tried all voices, back up one
// 0ad3: 2b LDAX (HL) // get voice number
// 0ad4: 1d MOV E,A // save
// 0ad5: 0b MOV A,C // note number in A, voice number in E
// 0ad6: ce JR $0AE5 // jump ahead to store and send
// 0ad7: 33 DCX HL // count down
// 0ad8: af 01 LDAX (HL+$01) // get voice in next slot up
// 0ada: 1b MOV C,A // save
// 0adb: 2b LDAX (HL) // get this voice
// 0adc: bf 01 STAX (HL+$01) // save in next slot up
// 0ade: 0b MOV A,C // restore
// 0adf: 3b STAX (HL) // swap voices
// 0ae0: 52 DCR B // count down voices to try
// 0ae1: f5 JR $0AD7 // loop back around
// 0ae2: 2a LDAX (DE) // ran out of voices, get note
// 0ae3: 07 7f ANI A,$7F // mask off top bit
// 0ae5: 3a STAX (DE) // save it back
// 0ae6: 74 c0 be ADDW $FFBE_transpose // add transpose
// 0ae9: 1b MOV C,A // save to C
// 0aea: 69 fd MVI A,$FD // select module board
// 0aec: 79 e8 CALF $09E8_sendToTx
// 0aee: 0d MOV A,E
// 0aee: 0d MOV A,E // voice number
// 0aef: 79 e8 CALF $09E8_sendToTx
// 0af1: 0b MOV A,C
// 0af1: 0b MOV A,C // note number
// 0af2: 79 e8 CALF $09E8_sendToTx
// 0af4: a2 POP DE
// 0af4: a2 POP DE // unstack and return
// 0af5: a1 POP BC
// 0af6: a3 POP HL
// 0af7: b8 RET
// voice functions
// -----------------------------------------------------------
// Real Poly 1 Note Off assigner
// -----------------------------------------------------------
// 0af8: b3 PUSH HL
// 0af9: b1 PUSH BC
// 0afa: b2 PUSH DE
// 0afb: 1b MOV C,A
// 0afc: 6a 05 MVI B,$05
// 0afe: 6c ff MVI D,$FF
// 0b00: 34 80 ff LXI HL,$FF80
// 0b03: 2b LDAX (HL)
// 0b04: 1d MOV E,A
// 0b05: 2a LDAX (DE)
// 0b06: 07 7f ANI A,$7F
// 0b08: 60 eb NEA A,C
// 0b0a: d0 JR $0B1B
// 0b0b: 32 INX HL
// 0b0c: 52 DCR B
// 0b0d: f5 JR $0B03
// 0b0e: a2 POP DE
// 0afb: 1b MOV C,A // save all
// 0afc: 6a 05 MVI B,$05 // six voices
// 0afe: 6c ff MVI D,$FF // set up DE as a pointer
// 0b00: 34 80 ff LXI HL,$FF80_voiceTbl
// 0b03: 2b LDAX (HL) // voice number
// 0b04: 1d MOV E,A // DE points to note table
// 0b05: 2a LDAX (DE) // get the note that's being played
// 0b06: 07 7f ANI A,$7F // mask off the play/stop bit
// 0b08: 60 eb NEA A,C // A != C?
// 0b0a: d0 JR $0B1B // found it
// 0b0b: 32 INX HL // next voice
// 0b0c: 52 DCR B // count down
// 0b0d: f5 JR $0B03 // loop
// 0b0e: a2 POP DE // return
// 0b0f: a1 POP BC
// 0b10: a3 POP HL
// 0b11: b8 RET
@ -1699,29 +1727,31 @@
// 0b17: 0b MOV A,C
// 0b18: bf 01 STAX (HL+$01)
// 0b1a: 32 INX HL
// 0b1b: 52 DCR B
// 0b1c: f5 JR $0B12
// 0b1d: 2a LDAX (DE)
// 0b1e: 17 80 ORI A,$80
// 0b20: 3a STAX (DE)
// 0b21: 0d MOV A,E
// 0b22: 66 08 SUI A,$08
// 0b24: 1b MOV C,A
// 0b1b: 52 DCR B // count down B anyway
// 0b1c: f5 JR $0B12 // if we're not done yet loop
// 0b1d: 2a LDAX (DE) // get note
// 0b1e: 17 80 ORI A,$80 // OR in "note off"
// 0b20: 3a STAX (DE) // save it back
// 0b21: 0d MOV A,E //
// 0b22: 66 08 SUI A,$08 // subtract 8 from the voice number
// 0b24: 1b MOV C,A // to put the correct command value in C
// 0b25: 69 fd MVI A,$FD // select module board
// 0b27: 79 e8 CALF $09E8_sendToTx
// 0b29: 0b MOV A,C
// 0b2a: 79 e8 CALF $09E8_sendToTx
// 0b2a: 79 e8 CALF $09E8_sendToTx // send 0x80 to 0x85 to the module board
// 0b2c: a2 POP DE
// 0b2d: a1 POP BC
// 0b2e: a3 POP HL
// 0b2f: b8 RET
// voice functions
// -----------------------------------------------------------
// test mode voice off cyclic thing
// -----------------------------------------------------------
// 0b30: b3 PUSH HL
// 0b31: b1 PUSH BC
// 0b32: 1b MOV C,A
// 0b33: 6a 05 MVI B,$05
// 0b35: 34 88 ff LXI HL,$FF88
// 0b35: 34 88 ff LXI HL,$FF88_noteTbl
// 0b38: 2b LDAX (HL)
// 0b39: 47 80 ONI A,$80
// 0b3b: c6 JR $0B42
@ -1752,7 +1782,7 @@
// 0b57: 74 c0 be ADDW $FFBE_transpose
// 0b5a: 1b MOV C,A
// 0b5b: 6a 05 MVI B,$05 // six voices
// 0b5d: 34 88 ff LXI HL,$FF88 // note table
// 0b5d: 34 88 ff LXI HL,$FF88_noteTbl // note table
// 0b60: 69 fd MVI A,$FD // select module board
// 0b62: 79 e8 CALF $09E8_sendToTx
// 0b64: 0f MOV A,L // voice on
@ -1781,13 +1811,13 @@
// 0b80: b8 RET
// set up new voice allocation table
// 0b81: 34 88 ff LXI HL,$FF88 // $FF88 to $FF8D contains $80
// 0b81: 34 88 ff LXI HL,$FF88_noteTbl // $FF88_noteTbl contains six bytes of $80
// 0b84: 6a 05 MVI B,$05
// 0b86: 69 80 MVI A,$80
// 0b88: 3d STAX (HL+)
// 0b89: 52 DCR B
// 0b8a: fd JR $0B88
// 0b8b: 34 80 ff LXI HL,$FF80 // $FF80 to $FF05 contains $88 to $8D
// 0b8b: 34 80 ff LXI HL,$FF80_voiceTbl // $FF80_voiceTbl contains $88 to $8D
// 0b8e: 6a 05 MVI B,$05
// 0b90: 69 88 MVI A,$88
// 0b92: 3d STAX (HL+)
@ -1976,7 +2006,7 @@
// 0ca6: b8 RET
// calculate address for patch data
// 0ca7: 58 b6 BIT 0,$FFB6 // are we in test mode
// 0ca7: 58 b6 BIT 0,$FFB6 // test mode? // are we in test mode
// 0ca9: c8 JR $0CB2 // no, skip ahead
// 0caa: 6e 0f MVI H,$0F // address is $0f00
// 0cac: 07 f0 ANI A,$F0

2781
plugin/module.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

42
plugin/parameters.cpp
View File

@ -290,6 +290,41 @@ void Chassis::initParameter(uint32_t index, Parameter& parameter) {
parameter.midiCC = 26;
break;
case paramChorusMode:
parameter.hints = kParameterIsAutomatable | kParameterIsInteger;
parameter.name = "Chorus";
parameter.symbol = "ch_chorusmode";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 2.0f;
parameter.ranges.def = 1.0f;
parameter.midiCC = 93;
break;
case paramPolyMode:
parameter.hints = kParameterIsAutomatable | kParameterIsInteger;
parameter.name = "Poly";
parameter.symbol = "ch_poly";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 2.0f;
parameter.ranges.def = 0.0f;
parameter.midiCC = 86;
parameter.enumValues.count = 3;
parameter.enumValues.restrictedMode = true;
{
ParameterEnumerationValue* const enumValues = new ParameterEnumerationValue[3];
enumValues[0].value = 0.0f;
enumValues[0].label = "16'";
enumValues[1].value = 1.0f;
enumValues[1].label = "8'";
enumValues[2].value = 2.0f;
enumValues[2].label = "4'";
parameter.enumValues.values = enumValues;
}
break;
case paramModWheel:
parameter.hints = kParameterIsAutomatable | kParameterIsHidden;
parameter.name = "Mod wheel";
@ -400,12 +435,15 @@ void Chassis::setParameterValue(uint32_t index, float value) {
printf("setPV %d %f\n", index, value);
if (value > 3) value = 3;
s.patchRam.switch2 &= 0xe7;
s.patchRam.switch2 |= (3-(int)value )<< 3;
s.patchRam.switch2 |= (3 - (int)value) << 3;
break;
case paramModWheel:
s.ff64 = (int)value << 1;
break;
case paramPolyMode:
s.polymode = (int)value;
break;
}
}
@ -453,7 +491,7 @@ float Chassis::getParameterValue(uint32_t index) const {
return s.patchRam.noise;
break;
case paramHPF:
return 3-((s.patchRam.switch2 & 0x18) >> 3);
return 3 - ((s.patchRam.switch2 & 0x18) >> 3);
break;
case paramVCFFreq:
return s.patchRam.vcfFreq;

2
plugin/voice.hpp
View File

@ -79,6 +79,8 @@ class Synth {
uint32_t blockLeft;
uint32_t framesLeft = 0;
uint8_t polymode;
bool keyon;
uint8_t ff63 = 0;