From b5701713806832b7b48ccb0230b06fa9c679202f Mon Sep 17 00:00:00 2001 From: Ricard Wanderlof Date: Sun, 24 Mar 2024 23:36:48 +0100 Subject: [PATCH] Change parameter range for most continuous params to 0..10 (#6) Instead of having 0.0 .. 1.0 as the range for continuous parameters, change to using 0 .. 10 which looks better in the GUI. Exceptions: - Filter tracking is still 0..1 (and should be increased to a maximum of 1.5 perhaps)? - Osc detune is still 0..1 (because it is in semitones, just like pitch). - However, it has been changed to be linear rather than log, so that the indicated value is in actual semitones. In Zynthian, the resolution is good enough, and means that the top end of the range is usable too (for negative detune, with pitch set one semitone lower). - Tune is -1..1 (because it is +/-1 one semitone). Also leave the unused1 and unused2 parameters at 0..1 . In conjunction with this, change the proc/process function name prefix to set for all parameter setting functions. --- plugins/mimid/Engine/AudioUtils.h | 5 +- plugins/mimid/Engine/Lfo.h | 2 +- plugins/mimid/Engine/ParamDefs.h | 164 +++++++++---------- plugins/mimid/Engine/SynthEngine.h | 252 +++++++++++++++-------------- plugins/mimid/Engine/Voice.h | 2 +- 5 files changed, 214 insertions(+), 211 deletions(-) diff --git a/plugins/mimid/Engine/AudioUtils.h b/plugins/mimid/Engine/AudioUtils.h index c53d3df..c0b8749 100644 --- a/plugins/mimid/Engine/AudioUtils.h +++ b/plugins/mimid/Engine/AudioUtils.h @@ -113,16 +113,17 @@ inline static float tptlpc(float &state, float inp, float lpc) inline static float linsc(float param,const float min,const float max) { - return (param) * (max - min) + min; + return (param * 0.1) * (max - min) + min; } inline static float logsc(float param, const float min,const float max,const float rolloff = 19.0f) { - return ((expf(param * logf(rolloff+1)) - 1.0f) / (rolloff)) * (max-min) + min; + return ((expf(param * 0.1 * logf(rolloff+1)) - 1.0f) / (rolloff)) * (max-min) + min; } inline static float timesc(float param, const float min, const float max) { + param *= 0.1; param *= param * param * param * param; // param ** 5 return param * (max - min) + min; } diff --git a/plugins/mimid/Engine/Lfo.h b/plugins/mimid/Engine/Lfo.h index 5d6f4cd..6a609b2 100644 --- a/plugins/mimid/Engine/Lfo.h +++ b/plugins/mimid/Engine/Lfo.h @@ -241,7 +241,7 @@ class Lfo void recalcRate(float param) { const int ratesCount = 9; - int parval = (int)(param*(ratesCount-1)); + int parval = (int)(param * (ratesCount - 1) / 10); float rt = 1; switch(parval) { diff --git a/plugins/mimid/Engine/ParamDefs.h b/plugins/mimid/Engine/ParamDefs.h index c58cc0a..96c7360 100644 --- a/plugins/mimid/Engine/ParamDefs.h +++ b/plugins/mimid/Engine/ParamDefs.h @@ -40,7 +40,7 @@ // ParamsEnum.h extracts the symbol (first parameter) in the macros // in order to create enums, like the Parameters enum (order is // important), - // MiMi-d.cpp sets up the process callbacks, and names and symbols + // MiMi-d.cpp sets up the set callbacks, and names and symbols // of the parameters (and in this case the order is not important). // Parameter groups @@ -93,136 +93,136 @@ // Parameters // Main - PARAM(VOLUME, PG_MAIN, SP_NONE, "Volume", "volume", 0.0, 1.0, 0.5, processVolume) - PARAM(PORTAMENTO, PG_MAIN, SP_NONE, "Portamento", "portamento", 0.0, 1.0, 0.0, processPortamento) - PARAM(TUNE, PG_MAIN, SP_NONE, "Tune", "tune", 0.0, 1.0, 0.5, processTune) - PARAM(OCTAVE, PG_MAIN, SP_OCTAVE, "Octave", "octave", 0.0, SP_MAX, 2, processOctave) + PARAM(VOLUME, PG_MAIN, SP_NONE, "Volume", "volume", 0, 10, 5, setVolume) + PARAM(PORTAMENTO, PG_MAIN, SP_NONE, "Portamento", "portamento", 0, 10, 0, setPortamento) + PARAM(TUNE, PG_MAIN, SP_NONE, "Tune", "tune", -1.0, 1.0, 0.0, setTune) + PARAM(OCTAVE, PG_MAIN, SP_OCTAVE, "Octave", "octave", 0, SP_MAX, 2, setOctave) // Key assignment #1 (general) - PARAM(VOICE_COUNT, PG_KEYASGN, SP_VOICECOUNT, "VoiceCount", "voicecount", 0.0, SP_MAX, 5, setVoiceCount) - PARAM(ASGN_MODE, PG_KEYASGN, SP_ASGNMODE, "Assign Mode", "keyasgnmode", 0.0, SP_MAX, 0.0, processKeyAsgnMode) + PARAM(VOICE_COUNT, PG_KEYASGN, SP_VOICECOUNT, "VoiceCount", "voicecount", 0, SP_MAX, 5, setVoiceCount) + PARAM(ASGN_MODE, PG_KEYASGN, SP_ASGNMODE, "Assign Mode", "keyasgnmode", 0, SP_MAX, 0, setKeyAsgnMode) // Envelope reset - PARAM(ENV_RST, PG_KEYASGN, SP_ENVRST, "Envelope Attack", "envrst", 0.0, SP_MAX, 0.0, procEnvRst) + PARAM(ENV_RST, PG_KEYASGN, SP_ENVRST, "Envelope Attack", "envrst", 0, SP_MAX, 0, setEnvRst) // Single trig: behavior during rob and restore - PARAM(ASGN_STRG, PG_KEYASGN, SP_ASGNSTRG, "Single Trig", "keyassignstrg", 0.0, SP_MAX, 0.0, procKeyAsgnStrg) + PARAM(ASGN_STRG, PG_KEYASGN, SP_ASGNSTRG, "Single Trig", "keyassignstrg", 0, SP_MAX, 0, setKeyAsgnStrg) // Key assignment #2 (modes) // ReSet to Zero (lowest) voice (default cyclic) - PARAM(ASGN_RSZ, PG_KEYASGN, SP_CYCRSZ, "Assign Order", "keyassignrsz", 0.0, SP_MAX, 0.0, procKeyAsgnRsz) + PARAM(ASGN_RSZ, PG_KEYASGN, SP_CYCRSZ, "Assign Order", "keyassignrsz", 0, SP_MAX, 0, setKeyAsgnRsz) // Prefer assign to voice previously with same note - PARAM(ASGN_MEM, PG_KEYASGN, SP_ASGNMEM, "Assign Memory", "keyassignmem", 0.0, SP_MAX, 0.0, procKeyAsgnMem) + PARAM(ASGN_MEM, PG_KEYASGN, SP_ASGNMEM, "Assign Memory", "keyassignmem", 0, SP_MAX, 0, setKeyAsgnMem) // Rob a playing voice if no unplaying available // two modes: oldest (O) and next-to-lowest (NL) - PARAM(ASGN_ROB, PG_KEYASGN, SP_ASGNROB, "Voice Rob", "keyassignrob", 0.0, SP_MAX, 0.0, procKeyAsgnRob) + PARAM(ASGN_ROB, PG_KEYASGN, SP_ASGNROB, "Voice Rob", "keyassignrob", 0, SP_MAX, 0, setKeyAsgnRob) // Restore mode: Store notes until voice available - PARAM(ASGN_RES, PG_KEYASGN, SP_ASGNRES, "Voice Restore", "keyassignres", 0.0, SP_MAX, 0.0, procKeyAsgnRes) + PARAM(ASGN_RES, PG_KEYASGN, SP_ASGNRES, "Voice Restore", "keyassignres", 0, SP_MAX, 0, setKeyAsgnRes) // Bend - PARAM(BENDRANGE, PG_BEND, SP_BENDRANGE, "Range", "bendrange", 0.0, SP_MAX, 0.0, procPitchWheelAmount) - PARAM(BENDDEST, PG_BEND, SP_BENDDEST, "Dest", "benddest", 0.0, SP_MAX, 0.0, procPitchWheelDest) + PARAM(BENDRANGE, PG_BEND, SP_BENDRANGE, "Range", "bendrange", 0, SP_MAX, 0, setPitchWheelAmount) + PARAM(BENDDEST, PG_BEND, SP_BENDDEST, "Dest", "benddest", 0, SP_MAX, 0, setPitchWheelDest) // LFO1 #1 (main: freq, wave, basic amount) - PARAM(LFO1FREQ, PG_LFO1, SP_NONE, "Rate", "lfo1rate", 0.0, 1.0, 0.0, processLfo1Frequency) - PARAM(LFO1WAVE, PG_LFO1, SP_LFOWAVE, "Wave", "lfo1wave", 0.0, SP_MAX, 0.0, processLfo1Wave) - PARAM(LFO1AMT, PG_LFO1, SP_NONE, "Iniital Amount", "lfo1amount", 0.0, 1.0, 0.0, processLfo1Amt) - PARAM(LFO1DEST, PG_LFO1, SP_LFODEST, "Dest", "lfo1dest", 0.0, SP_MAX, 0.0, processLfo1Dest) + PARAM(LFO1FREQ, PG_LFO1, SP_NONE, "Rate", "lfo1rate", 0, 10, 0, setLfo1Frequency) + PARAM(LFO1WAVE, PG_LFO1, SP_LFOWAVE, "Wave", "lfo1wave", 0, SP_MAX, 0, setLfo1Wave) + PARAM(LFO1AMT, PG_LFO1, SP_NONE, "Iniital Amount", "lfo1amount", 0, 10, 0, setLfo1Amt) + PARAM(LFO1DEST, PG_LFO1, SP_LFODEST, "Dest", "lfo1dest", 0, SP_MAX, 0, setLfo1Dest) // LFO1 #2 (secondary: sync, controllers, polarity) - PARAM(LFO1_CONTRAMT, PG_LFO1, SP_NONE, "Controller Amount", "lfo1contramt", 0.0, 1.0, 0.0, procLfo1ControllerAmt) - PARAM(LFO1_AMT_CTRL, PG_LFO1, SP_LFOCONTR, "Controller", "lfo1amtcont", 0.0, SP_MAX, 0.0, procLfo1Controller) - PARAM(LFO1_POLARITY, PG_LFO1, SP_POLARITY, "Polarity", "lfo1polarity", 0.0, SP_MAX, 0.0, procLfo1Polarity) - PARAM(LFO1SYNC, PG_LFO1, SP_LFOSYNC, "Sync", "lfo1sync", 0.0, SP_MAX, 0.0, procLfo1Sync) + PARAM(LFO1_CONTRAMT, PG_LFO1, SP_NONE, "Controller Amount", "lfo1contramt", 0, 10, 0, setLfo1ControllerAmt) + PARAM(LFO1_AMT_CTRL, PG_LFO1, SP_LFOCONTR, "Controller", "lfo1amtcont", 0, SP_MAX, 0, setLfo1Controller) + PARAM(LFO1_POLARITY, PG_LFO1, SP_POLARITY, "Polarity", "lfo1polarity", 0, SP_MAX, 0, setLfo1Polarity) + PARAM(LFO1SYNC, PG_LFO1, SP_LFOSYNC, "Sync", "lfo1sync", 0, SP_MAX, 0, setLfo1Sync) // LFO2 #1 (main: freq, wave, basic amount) - PARAM(LFO2FREQ, PG_LFO2, SP_NONE, "Rate", "lfo2frequency", 0.0, 1.0, 0.6, processLfo2Frequency) - PARAM(LFO2WAVE, PG_LFO2, SP_LFOWAVE, "Wave", "lfo2wave", 0.0, SP_MAX, 0.0, processLfo2Wave) - PARAM(LFO2AMT, PG_LFO2, SP_NONE, "Iniital Amount", "lfo2amount", 0.0, 1.0, 0.0, processLfo2Amt) - PARAM(LFO2DEST, PG_LFO2, SP_LFODEST, "Dest", "lfo2dest", 0.0, SP_MAX, 0.0, processLfo2Dest) + PARAM(LFO2FREQ, PG_LFO2, SP_NONE, "Rate", "lfo2frequency", 0, 10, 6, setLfo2Frequency) + PARAM(LFO2WAVE, PG_LFO2, SP_LFOWAVE, "Wave", "lfo2wave", 0, SP_MAX, 0, setLfo2Wave) + PARAM(LFO2AMT, PG_LFO2, SP_NONE, "Iniital Amount", "lfo2amount", 0, 10, 0, setLfo2Amt) + PARAM(LFO2DEST, PG_LFO2, SP_LFODEST, "Dest", "lfo2dest", 0, SP_MAX, 0, setLfo2Dest) // LFO2 #2 (secondary: sync, controllers, polarity) - PARAM(LFO2_CONTRAMT, PG_LFO2, SP_NONE, "Controller Amount", "lfo2contramt", 0.0, 1.0, 0.0, procLfo2ControllerAmt) - PARAM(LFO2_AMT_CTRL, PG_LFO2, SP_LFOCONTR, "Controller", "lfo2amtcont", 0.0, SP_MAX, 0.0, procLfo2Controller) - PARAM(LFO2_POLARITY, PG_LFO2, SP_POLARITY, "Polarity", "lfo2polarity", 0.0, SP_MAX, 0.0, procLfo2Polarity) - PARAM(LFO2SYNC, PG_LFO2, SP_LFOSYNC, "Sync", "lfo2sync", 0.0, SP_MAX, 0.0, procLfo2Sync) + PARAM(LFO2_CONTRAMT, PG_LFO2, SP_NONE, "Controller Amount", "lfo2contramt", 0, 10, 0, setLfo2ControllerAmt) + PARAM(LFO2_AMT_CTRL, PG_LFO2, SP_LFOCONTR, "Controller", "lfo2amtcont", 0, SP_MAX, 0, setLfo2Controller) + PARAM(LFO2_POLARITY, PG_LFO2, SP_POLARITY, "Polarity", "lfo2polarity", 0, SP_MAX, 0, setLfo2Polarity) + PARAM(LFO2SYNC, PG_LFO2, SP_LFOSYNC, "Sync", "lfo2sync", 0, SP_MAX, 0, setLfo2Sync) // Osc 1 - PARAM(OSC1_DET, PG_OSC1, SP_NONE, "Detune", "osc1detune", 0.0, 1.0, 0.0, processOsc1Det) - PARAM(OSC1P, PG_OSC1, SP_OSCFREQ, "Pitch", "osc1pitch", 0.0, SP_MAX, 0.0, processOsc1Pitch) - PARAM(OSC1PW, PG_OSC1, SP_NONE, "PulseWidth", "osc1pw", 0.0, 1.0, 0.0, processOsc1PulseWidth) - PARAM(OSC1WAVE, PG_OSC1, SP_OSCWAVE, "Wave", "osc1wave", 0.0, SP_MAX, 1.0, processOsc1Wave) + PARAM(OSC1_DET, PG_OSC1, SP_NONE, "Detune", "osc1detune", 0.0, 1.0, 0.0, setOsc1Det) + PARAM(OSC1P, PG_OSC1, SP_OSCFREQ, "Pitch", "osc1pitch", 0, SP_MAX, 0, setOsc1Pitch) + PARAM(OSC1PW, PG_OSC1, SP_NONE, "PulseWidth", "osc1pw", 0, 10, 0, setOsc1PulseWidth) + PARAM(OSC1WAVE, PG_OSC1, SP_OSCWAVE, "Wave", "osc1wave", 0, SP_MAX, 0, setOsc1Wave) // Osc 2 - PARAM(OSC2_DET, PG_OSC2, SP_NONE, "Detune", "osc2detune", 0.0, 1.0, 0.0, processOsc2Det) - PARAM(OSC2P, PG_OSC2, SP_OSCFREQ, "Pitch", "osc2pitch", 0.0, SP_MAX, 0.0, processOsc2Pitch) - PARAM(OSC2PW, PG_OSC2, SP_NONE, "PulseWidth", "osc2pw", 0.0, 1.0, 0.0, processOsc2PulseWidth) - PARAM(OSC2WAVE, PG_OSC2, SP_OSCWAVE, "Wave", "osc2wave", 0.0, SP_MAX, 1.0, processOsc2Wave) + PARAM(OSC2_DET, PG_OSC2, SP_NONE, "Detune", "osc2detune", 0.0, 1.0, 0.0, setOsc2Det) + PARAM(OSC2P, PG_OSC2, SP_OSCFREQ, "Pitch", "osc2pitch", 0, SP_MAX, 0, setOsc2Pitch) + PARAM(OSC2PW, PG_OSC2, SP_NONE, "PulseWidth", "osc2pw", 0, 10, 0, setOsc2PulseWidth) + PARAM(OSC2WAVE, PG_OSC2, SP_OSCWAVE, "Wave", "osc2wave", 0, SP_MAX, 1, setOsc2Wave) // Osc common (osc modulation and key sync) - PARAM(XMOD, PG_OSC_COM, SP_NONE, "Xmod", "xmod", 0.0, 1.0, 0.0, processOsc2Xmod) - PARAM(OSC2FLTMOD, PG_OSC_COM, SP_NONE, "Osc2FilterMod", "osc2filtermod", 0.0, 1.0, 0.0, processOsc2FltMod) - PARAM(OSCSYNC_LEVEL, PG_OSC_COM, SP_NONE, "SyncLevel", "synclevel", 0.0, 1.0, 0.0, processOsc2SyncLevel) - PARAM(OSC_KEY_SYNC, PG_OSC_COM, SP_KEYSYNC, "Waveform Reset", "osckeysync", 0.0, SP_MAX, 0.0, procOscKeySync) + PARAM(XMOD, PG_OSC_COM, SP_NONE, "Xmod", "xmod", 0, 10, 0, setOsc2Xmod) + PARAM(OSC2FLTMOD, PG_OSC_COM, SP_NONE, "Osc2FilterMod", "osc2filtermod", 0, 10, 0, setOsc2FltMod) + PARAM(OSCSYNC_LEVEL, PG_OSC_COM, SP_NONE, "SyncLevel", "synclevel", 0, 10, 0, setOsc2SyncLevel) + PARAM(OSC_KEY_SYNC, PG_OSC_COM, SP_KEYSYNC, "Waveform Reset", "osckeysync", 0, SP_MAX, 0, setOscKeySync) // Mixer and osc 3 - PARAM(OSC1MIX, PG_MIXER, SP_NONE, "Osc1Mix", "osc1mix", 0.0, 1.0, 0.0, processOsc1Mix) - PARAM(OSC2MIX, PG_MIXER, SP_NONE, "Osc2Mix", "osc2mix", 0.0, 1.0, 1.0, processOsc2Mix) - PARAM(OSC3MIX, PG_MIXER, SP_NONE, "Osc3Mix", "osc3mix", 0.0, 1.0, 0.0, processOsc3Mix) - PARAM(OSC3WAVE, PG_MIXER, SP_OSC3WAVE, "Osc3Wave", "osc3wave",0.0, SP_MAX, 0.0, processOsc3Wave) + PARAM(OSC1MIX, PG_MIXER, SP_NONE, "Osc1Mix", "osc1mix", 0, 10, 0, setOsc1Mix) + PARAM(OSC2MIX, PG_MIXER, SP_NONE, "Osc2Mix", "osc2mix", 0, 10, 10, setOsc2Mix) + PARAM(OSC3MIX, PG_MIXER, SP_NONE, "Osc3Mix", "osc3mix", 0, 10, 0, setOsc3Mix) + PARAM(OSC3WAVE, PG_MIXER, SP_OSC3WAVE, "Osc3Wave", "osc3wave", 0, SP_MAX, 0, setOsc3Wave) // Filter - PARAM(CUTOFF, PG_FILTER, SP_NONE, "Cutoff", "cutoff", 0.0, 1.0, 1.0, processCutoff) - PARAM(RESONANCE, PG_FILTER, SP_NONE, "Resonance", "resonance", 0.0, 1.0, 0.0, processResonance) - PARAM(FLT_KF, PG_FILTER, SP_NONE, "KeyTrack", "keytrack", 0.0, 1.0, 0.0, processFilterKeyFollow) - PARAM(ENVELOPE_AMT, PG_FILTER, SP_NONE, "EnvAmount", "filterenvamount", 0.0, 1.0, 0.0, processFilterEnvelopeAmt) + PARAM(CUTOFF, PG_FILTER, SP_NONE, "Cutoff", "cutoff", 0, 10, 10, setCutoff) + PARAM(RESONANCE, PG_FILTER, SP_NONE, "Resonance", "resonance", 0, 10, 0, setResonance) + PARAM(FLT_KF, PG_FILTER, SP_NONE, "KeyTrack", "keytrack", 0.0, 1.0, 0.0, setFilterKeyFollow) + PARAM(ENVELOPE_AMT, PG_FILTER, SP_NONE, "EnvAmount", "filterenvamount", 0, 10, 0, setFilterEnvelopeAmt) // Filter configuration - PARAM(RESPONSE, PG_FILTERCFG, SP_NONE, "Pole Count", "response", 1.0, 4.0, 4.0, processResponse) - PARAM(FENV_INVERT, PG_FILTERCFG, SP_ONOFF, "Env Invert", "fenvinvert", 0.0, SP_MAX, 0.0, processInvertFenv) - PARAM(FENV_LINEAR, PG_FILTERCFG, SP_ONOFF, "Linear Env", "fenvlinear", 0.0, SP_MAX, 0.0, procFenvLinear) + PARAM(RESPONSE, PG_FILTERCFG, SP_NONE, "Pole Count", "response", 1, 4, 4, setResponse) + PARAM(FENV_INVERT, PG_FILTERCFG, SP_ONOFF, "Env Invert", "fenvinvert", 0, SP_MAX, 0, setInvertFenv) + PARAM(FENV_LINEAR, PG_FILTERCFG, SP_ONOFF, "Linear Env", "fenvlinear", 0, SP_MAX, 0, setFenvLinear) // FENV - PARAM(FATK, PG_FENV, SP_NONE, "Attack", "filterattack", 0.0, 1.0, 0.0, processFilterEnvelopeAttack) - PARAM(FDEC, PG_FENV, SP_NONE, "Decay", "filterdecay", 0.0, 1.0, 0.0, processFilterEnvelopeDecay) - PARAM(FSUS, PG_FENV, SP_NONE, "Sustain", "filtersustain", 0.0, 1.0, 1.0, processFilterEnvelopeSustain) - PARAM(FSUST, PG_FENV, SP_NONE, "SustainTime", "filtersustaintime", 0.0, 1.0, 1.0, processFilterEnvelopeSustainTime) + PARAM(FATK, PG_FENV, SP_NONE, "Attack", "filterattack", 0, 10, 0, setFilterEnvelopeAttack) + PARAM(FDEC, PG_FENV, SP_NONE, "Decay", "filterdecay", 0, 10, 0, setFilterEnvelopeDecay) + PARAM(FSUS, PG_FENV, SP_NONE, "Sustain", "filtersustain", 0, 10, 10, setFilterEnvelopeSustain) + PARAM(FSUST, PG_FENV, SP_NONE, "SustainTime", "filtersustaintime", 0, 10, 10, setFilterEnvelopeSustainTime) // LENV - PARAM(LATK, PG_LENV, SP_NONE, "Attack", "attack", 0.0, 1.0, 0.0, processLoudnessEnvelopeAttack) - PARAM(LDEC, PG_LENV, SP_NONE, "Decay", "decay", 0.0, 1.0, 0.0, processLoudnessEnvelopeDecay) - PARAM(LSUS, PG_LENV, SP_NONE, "Sustain", "sustain", 0.0, 1.0, 1.0, processLoudnessEnvelopeSustain) - PARAM(LSUST, PG_LENV, SP_NONE, "SustainTime", "sustaintime", 0.0, 1.0, 1.0, processLoudnessEnvelopeSustainTime) + PARAM(LATK, PG_LENV, SP_NONE, "Attack", "attack", 0, 10, 0, setLoudnessEnvelopeAttack) + PARAM(LDEC, PG_LENV, SP_NONE, "Decay", "decay", 0, 10, 0, setLoudnessEnvelopeDecay) + PARAM(LSUS, PG_LENV, SP_NONE, "Sustain", "sustain", 0, 10, 10, setLoudnessEnvelopeSustain) + PARAM(LSUST, PG_LENV, SP_NONE, "SustainTime", "sustaintime", 0, 10, 10, setLoudnessEnvelopeSustainTime) // Env release - PARAM(FREL, PG_REL, SP_NONE, "Filter Release", "filterrelease", 0.0, 1.0, 0.0, processFilterEnvelopeRelease) - PARAM(LREL, PG_REL, SP_NONE, "Loudness Release", "release", 0.0, 1.0, 0.0, processLoudnessEnvelopeRelease) + PARAM(FREL, PG_REL, SP_NONE, "Filter Release", "filterrelease", 0, 10, 0, setFilterEnvelopeRelease) + PARAM(LREL, PG_REL, SP_NONE, "Loudness Release", "release", 0, 10, 0, setLoudnessEnvelopeRelease) // VCA (+ Loudness envelope control) - PARAM(HPFFREQ, PG_VCA, SP_NONE, "HPFfreq", "hpffreq", 0.0, 1.0, 0.0, processHPFfreq) - PARAM(VCADRIVE, PG_VCA, SP_NONE, "VCADrive", "vcadrive", 0.0, 1.0, 0.0, processVCADrive) - PARAM(ENV_MODE, PG_VCA, SP_ENVMODE, "EnvMode", "envmode", 0.0, SP_MAX, 0.0, procEnvMode) + PARAM(HPFFREQ, PG_VCA, SP_NONE, "HPFfreq", "hpffreq", 0, 10, 0, setHPFfreq) + PARAM(VCADRIVE, PG_VCA, SP_NONE, "VCADrive", "vcadrive", 0, 10, 0, setVCADrive) + PARAM(ENV_MODE, PG_VCA, SP_ENVMODE, "EnvMode", "envmode", 0, SP_MAX, 0, setEnvMode) // Controller sensitivity and control (velocity and aftertouch) - PARAM(VEL_SCALE, PG_CONTR, SP_NONE, "Velocity Scale", "velocityscale", 0.0, 1.0, 0.0, procVelocityScale) - PARAM(AT_SCALE, PG_CONTR, SP_NONE, "AfterTouch Scale", "aftertouchscale", 0.0, 1.0, 0.0, procAfterTouchScale) - PARAM(VFLTENV, PG_CONTR, SP_NONE, "FilterEnv Velocity", "vfltfactor", 0.0, 1.0, 0.0, procFltVelocityAmount) - PARAM(VAMPENV, PG_CONTR, SP_NONE, "Amp Velocity", "vampfactor", 0.0, 1.0, 0.0, procAmpVelocityAmount) + PARAM(VEL_SCALE, PG_CONTR, SP_NONE, "Velocity Scale", "velocityscale", 0, 10, 5, setVelocityScale) + PARAM(AT_SCALE, PG_CONTR, SP_NONE, "AfterTouch Scale", "aftertouchscale", 0, 10, 5, setAfterTouchScale) + PARAM(VFLTENV, PG_CONTR, SP_NONE, "FilterEnv Velocity", "vfltfactor", 0, 10, 0, setFltVelocityAmount) + PARAM(VAMPENV, PG_CONTR, SP_NONE, "Amp Velocity", "vampfactor", 0, 10, 0, setAmpVelocityAmount) // Spread control // #1 (freqs and levels) - PARAM(UDET, PG_SPREAD, SP_NONE, "OscSpread", "oscspread", 0.0, 1.0, 0.2, processOscSpread) - PARAM(FILTERDER, PG_SPREAD, SP_NONE, "FilterSpread", "filtespread", 0.0, 1.0, 0.3, processFilterSpread) - PARAM(LEVEL_DIF, PG_SPREAD, SP_NONE, "LevelSpread", "levelspread", 0.0, 1.0, 0.3, processLoudnessSpread) - PARAM(PANSPREAD, PG_SPREAD, SP_NONE, "PanSpread", "panspread", 0.0, 1.0, 0.1, processPanSpread) + PARAM(UDET, PG_SPREAD, SP_NONE, "OscSpread", "oscspread", 0, 10, 2, setOscSpread) + PARAM(FILTERDER, PG_SPREAD, SP_NONE, "FilterSpread", "filtespread", 0, 10, 3, setFilterSpread) + PARAM(LEVEL_DIF, PG_SPREAD, SP_NONE, "LevelSpread", "levelspread", 0, 10, 3, setLoudnessSpread) + PARAM(PANSPREAD, PG_SPREAD, SP_NONE, "PanSpread", "panspread", 0, 10, 1, setPanSpread) // #2 (times and speeds) - PARAM(ENVDER, PG_SPREAD, SP_NONE, "EnvelopeSpread", "envelopspread", 0.0, 1.0, 0.0, processEnvelopeSpread) - PARAM(PORTADER, PG_SPREAD, SP_NONE, "PortamentoSpread", "portamentospread", 0.0, 1.0, 0.3, processPortamentoSpread) - PARAM(LFOSPREAD, PG_SPREAD, SP_NONE, "LfoSpread", "lfospread", 0.0, 1.0, 0.0, processLfoSpread) + PARAM(ENVDER, PG_SPREAD, SP_NONE, "EnvelopeSpread", "envelopspread", 0, 10, 0, setEnvelopeSpread) + PARAM(PORTADER, PG_SPREAD, SP_NONE, "PortamentoSpread", "portamentospread", 0, 10, 3, setPortamentoSpread) + PARAM(LFOSPREAD, PG_SPREAD, SP_NONE, "LfoSpread", "lfospread", 0, 10, 0, setLfoSpread) // DSP control - PARAM(OVERSAMPLE, PG_DSP, SP_ONOFF, "Oversample", "oversample", 0.0, SP_MAX, 1.0, processOversampling) - PARAM(ECONOMY_MODE, PG_DSP, SP_ONOFF, "Economy Mode", "economymode", 0.0, SP_MAX, 1.0, procEconomyMode) + PARAM(OVERSAMPLE, PG_DSP, SP_ONOFF, "Oversample", "oversample", 0, SP_MAX, 10, setOversampling) + PARAM(ECONOMY_MODE, PG_DSP, SP_ONOFF, "Economy Mode", "economymode", 0, SP_MAX, 10, setEconomyMode) // Misc/Debug - PARAM(UNUSED_1, PG_MISC, SP_NONE, "Debug 1", "unused_1", 0.0, 1.0, 0.0, procUnused1) - PARAM(UNUSED_2, PG_MISC, SP_NONE, "Debug 2", "unused_2", 0.0, 1.0, 0.0, procUnused2) + PARAM(UNUSED_1, PG_MISC, SP_NONE, "Debug 1", "unused_1", 0, 1.0, 0, procUnused1) + PARAM(UNUSED_2, PG_MISC, SP_NONE, "Debug 2", "unused_2", 0, 1.0, 0, procUnused2) // Clean up for potential re-inclusion of file with new definitions #undef PARAMPOINTS diff --git a/plugins/mimid/Engine/SynthEngine.h b/plugins/mimid/Engine/SynthEngine.h index 8b05201..cbdf6d8 100644 --- a/plugins/mimid/Engine/SynthEngine.h +++ b/plugins/mimid/Engine/SynthEngine.h @@ -110,7 +110,7 @@ class SynthEngine { synth.sustainOff(); } - void procLfo1Sync(float val) + void setLfo1Sync(float val) { // Off - Tempo - Key - Oneshot int intval = roundToInt(val); @@ -121,7 +121,7 @@ class SynthEngine synth.voices[i].lfo1.setOneShot(intval == 3); } } - void procLfo2Sync(float val) + void setLfo2Sync(float val) { // Off - Tempo - Key - Oneshot int intval = roundToInt(val); @@ -132,45 +132,45 @@ class SynthEngine synth.voices[i].lfo2.setOneShot(intval == 3); } } - void procLfo1Polarity(float val) + void setLfo1Polarity(float val) { // Normal - Invert - Unipolar - Unipolar+Invert int intval = roundToInt(val); ForEachVoice(lfo1.invert = (intval & 1)); ForEachVoice(lfo1.unipolar = (intval & 2)); } - void procLfo2Polarity(float val) + void setLfo2Polarity(float val) { // Normal - Invert - Unipolar - Unipolar+Invert int intval = roundToInt(val); ForEachVoice(lfo2.invert = (intval & 1)); ForEachVoice(lfo2.unipolar = (intval & 2)); } - void procKeyAsgnRsz(float val) + void setKeyAsgnRsz(float val) { synth.voiceAlloc.rsz = roundToInt(val); } - void procKeyAsgnMem(float val) + void setKeyAsgnMem(float val) { synth.voiceAlloc.mem = roundToInt(val); } - void procKeyAsgnRob(float val) + void setKeyAsgnRob(float val) { int intval = roundToInt(val); synth.voiceAlloc.rob_oldest = intval == 1; synth.voiceAlloc.rob_next_to_lowest = intval == 2; } - void procKeyAsgnRes(float val) + void setKeyAsgnRes(float val) { synth.voiceAlloc.restore = roundToInt(val); } - void procKeyAsgnStrg(float val) + void setKeyAsgnStrg(float val) { int intval = roundToInt(val); synth.voiceAlloc.strgNoteOff = intval == 1 || intval == 2; synth.voiceAlloc.strgNoteOn = intval == 2; } - void processKeyAsgnMode(float param) + void setKeyAsgnMode(float param) { // Poly - Mono - Mono+Auto [Portamento] int intval = roundToInt(param); @@ -185,7 +185,7 @@ class SynthEngine { synth.voiceAlloc.setNoteOff(noteNo); } - void procEconomyMode(float val) + void setEconomyMode(float val) { synth.economyMode = roundToInt(val); } @@ -210,23 +210,23 @@ class SynthEngine ForEachVoice(env.unused2=val); ForEachVoice(fenv.unused2=val); } - void procAmpVelocityAmount(float val) + void setAmpVelocityAmount(float val) { - ForEachVoice(vamp = val); + ForEachVoice(vamp = val * 0.1f); } - void procFltVelocityAmount(float val) + void setFltVelocityAmount(float val) { - ForEachVoice(vflt = val); + ForEachVoice(vflt = val * 0.1f); } - void procVelocityScale(float scale) + void setVelocityScale(float scale) { - scale = 1 - 2 * scale; // 0..1 -> 1..0..-1 + scale = 1 - 0.2 * scale; // 0..10 -> 1..0..-1 scale = powf(8.0, scale); // => 8 .. 1 .. 1/8 ForEachVoice(velscale = scale); } - void procAfterTouchScale(float scale) + void setAfterTouchScale(float scale) { - scale = 1 - 2 * scale; // 0..1 -> 1..0..-1 + scale = 1 - 0.2 * scale; // 0..10 -> 1..0..-1 atscale = powf(8.0, scale); // => 8 .. 1 .. 1/8 } void procModWheel(float val) @@ -246,12 +246,12 @@ class SynthEngine { ForEachVoice(aftert = val); } - void processLfo2Frequency(float val) + void setLfo2Frequency(float val) { for(int i = 0 ; i < synth.MAX_VOICES;i++) { synth.voices[i].lfo2.setRawFrequency(val); - synth.voices[i].lfo2.setFrequency(logsc(val,0,100,240)); + synth.voices[i].lfo2.setFrequency(logsc(val, 0, 100, 240)); } } void procPitchWheel(float val) @@ -266,12 +266,12 @@ class SynthEngine { synth.setVoiceCount(roundToInt(param) + 1); } - void procPitchWheelAmount(float param) + void setPitchWheelAmount(float param) { int intparam = roundToInt(param); ForEachVoice(pitchWheelAmt = intparam); } - void procPitchWheelDest(float param) + void setPitchWheelDest(float param) { // OFF - OSC1 - OSC1+2 int intparam = roundToInt(param); @@ -281,55 +281,55 @@ class SynthEngine synth.voices[i].pitchWheelOsc2 = intparam == 2; } } - void processPanSpread(float param) + void setPanSpread(float param) { - synth.SetPanSpreadAmt(param); + synth.SetPanSpreadAmt(param * 0.1f); } - void processTune(float param) + void setTune(float param) { - ForEachVoice(osc.tune = param*2-1); + ForEachVoice(osc.tune = param); } - void processOctave(float param) + void setOctave(float param) { ForEachVoice(osc.oct = (roundToInt(param) - 2) * 12); } - void processFilterKeyFollow(float param) + void setFilterKeyFollow(float param) { ForEachVoice(fltKF = param); } - void processPortamento(float param) + void setPortamento(float param) { - float porta = logsc(1-param,0.14,250,150); + float porta = logsc(10 - param, 0.14, 250, 150); ForEachVoice(setPorta(porta)); } - void processVolume(float param) + void setVolume(float param) { - synth.Volume = linsc(param,0,0.30); + synth.Volume = linsc(param, 0, 0.30); } - void processLfo1Frequency(float param) + void setLfo1Frequency(float param) { for(int i = 0 ; i < synth.MAX_VOICES;i++) { synth.voices[i].lfo1.setRawFrequency(param); - synth.voices[i].lfo1.setFrequency(logsc(param,0,100,240)); + synth.voices[i].lfo1.setFrequency(logsc(param, 0, 100, 240)); } } - void processLfo1Wave(float param) + void setLfo1Wave(float param) { int intparam = roundToInt(param); ForEachVoice(lfo1.setWaveForm(intparam)); } - void processLfo2Wave(float param) + void setLfo2Wave(float param) { int intparam = roundToInt(param); ForEachVoice(lfo2.setWaveForm(intparam)); } - void processLfo1Amt(float param) + void setLfo1Amt(float param) { - ForEachVoice(lfo1amt = param); + ForEachVoice(lfo1amt = param * 0.1f); } - void processLfo1Dest(float param) + void setLfo1Dest(float param) { int intparam = roundToInt(param); // off, osc1, osc1+2, osc2, pw1, pw1+2, pw2, filt, res, bmod @@ -352,7 +352,7 @@ class SynthEngine synth.voices[i].lfo1bmod = lfo1bmod; } } - void processLfo2Dest(float param) + void setLfo2Dest(float param) { int intparam = roundToInt(param); // off, osc1, osc1+2, osc2, pw1, pw1+2, pw2, filt, res, bmod @@ -375,7 +375,7 @@ class SynthEngine synth.voices[i].lfo2bmod = lfo2bmod; } } - void procLfo1Controller(float val) + void setLfo1Controller(float val) { int intval = roundToInt(val); // off - modwheel - aftertouch - lfo2 @@ -383,11 +383,11 @@ class SynthEngine ForEachVoice(lfo1after = (intval == 2)); ForEachVoice(lfo1vel = (intval == 3)); } - void procLfo1ControllerAmt(float val) + void setLfo1ControllerAmt(float val) { - ForEachVoice(lfo1modamt = val); + ForEachVoice(lfo1modamt = val * 0.1f); } - void procLfo2Controller(float val) + void setLfo2Controller(float val) { int intval = roundToInt(val); // off - modwheel - aftertouch - lfo1 @@ -395,87 +395,89 @@ class SynthEngine ForEachVoice(lfo2after = (intval == 2)); ForEachVoice(lfo2vel = (intval == 3)); } - void procLfo2ControllerAmt(float val) + void setLfo2ControllerAmt(float val) { - ForEachVoice(lfo2modamt = val); + ForEachVoice(lfo2modamt = val * 0.1f); } - void processLfo2Amt(float param) + void setLfo2Amt(float param) { - ForEachVoice(lfo2amt = param); + ForEachVoice(lfo2amt = param * 0.1f); } - void processOscSpread(float param) + void setOscSpread(float param) { - ForEachVoice(osc.totalSpread = logsc(param,0.001,0.90)); + ForEachVoice(osc.totalSpread = logsc(param, 0.001, 0.90)); } - void processOsc1PulseWidth(float param) + void setOsc1PulseWidth(float param) { - ForEachVoice (osc.osc1pw = param); + ForEachVoice (osc.osc1pw = param * 0.1f); } - void processOsc2PulseWidth(float param) + void setOsc2PulseWidth(float param) { - ForEachVoice (osc.osc2pw = param); + ForEachVoice (osc.osc2pw = param * 0.1f); } - void processInvertFenv(float param) + void setInvertFenv(float param) { ForEachVoice(invertFenv = roundToInt(param)); } - void procFenvLinear(float param) + void setFenvLinear(float param) { ForEachVoice(fenv.setLinear(roundToInt(param))); } - void procEnvMode(float param) + void setEnvMode(float param) { // Exp env / Lin VCA - Lin env / Lin VCA - Lin env / Exp VCA int intparam = roundToInt(param); ForEachVoice(env.setLinear(intparam >= 1)); ForEachVoice(expvca = (intparam >= 2)); } - void processOsc2Xmod(float param) + void setOsc2Xmod(float param) { - ForEachVoice(osc.xmod = param * 24); + ForEachVoice(osc.xmod = param * 2.4f); } - void processOsc2SyncLevel(float param) + void setOsc2SyncLevel(float param) { - ForEachVoice(osc.syncLevel = 1.0 - param); + ForEachVoice(osc.syncLevel = 1.0f - param * 0.1f); } - void processOsc1Pitch(float param) + void setOsc1Pitch(float param) { ForEachVoice(osc.osc1p = roundToInt(param)); } - void processOsc2Pitch(float param) + void setOsc2Pitch(float param) { ForEachVoice(osc.osc2p = roundToInt(param)); } - void processOsc1Mix(float param) + void setOsc1Mix(float param) { - ForEachVoice(osc.o1mx = param); + ForEachVoice(osc.o1mx = param * 0.1f); } - void processOsc2Mix(float param) + void setOsc2Mix(float param) { - ForEachVoice(osc.o2mx = param); + ForEachVoice(osc.o2mx = param * 0.1f); } - void processHPFfreq(float param) + void setHPFfreq(float param) { - ForEachVoice(setHPFfreq(param)); + ForEachVoice(setHPFfreq(logsc(param, 4, 2500))); } - void processVCADrive(float param) + void setVCADrive(float param) { - ForEachVoice(sqdist.setAmount(param * 0.435)); + ForEachVoice(sqdist.setAmount(param * 0.0435f)); } - void processOsc2FltMod(float param) + void setOsc2FltMod(float param) { - ForEachVoice(osc2FltMod = param * 100); + ForEachVoice(osc2FltMod = param * 10); } - void processOsc1Det(float param) + void setOsc1Det(float param) { - ForEachVoice(osc.osc1Det = logsc(param,0.001,0.6)); + // logsc is geared for 0..10. so we multiply param by 10 + // as the displayed parameter value is 0..1. + ForEachVoice(osc.osc1Det = linsc(param * 10, 0, 1.0)); } - void processOsc2Det(float param) + void setOsc2Det(float param) { - ForEachVoice(osc.osc2Det = logsc(param,0.001,0.6)); + ForEachVoice(osc.osc2Det = linsc(param * 10, 0, 1.0)); } - void processOsc1Wave(float param) + void setOsc1Wave(float param) { int intparam = roundToInt(param); for(int i = 0 ; i < synth.MAX_VOICES;i++) @@ -488,7 +490,7 @@ class SynthEngine } } - void processOsc2Wave(float param) + void setOsc2Wave(float param) { int intparam = roundToInt(param); for(int i = 0 ; i < synth.MAX_VOICES;i++) @@ -498,111 +500,111 @@ class SynthEngine synth.voices[i].osc.osc2Tri = intparam == 3; } } - void processOsc3Wave(float param) + void setOsc3Wave(float param) { int intparam = roundToInt(param); // off - -1 square - -2 square - -2 pulse - noise ForEachVoice(osc.osc3Waveform = intparam); } - void processOsc3Mix(float param) + void setOsc3Mix(float param) { - ForEachVoice(osc.o3mx = param); + ForEachVoice(osc.o3mx = param * 0.1f); } - void processCutoff(float param) + void setCutoff(float param) { - cutoffSmoother.setSteep( linsc(param,0,120)); + cutoffSmoother.setSteep(linsc(param, 0, 120)); } inline void processCutoffSmoothed(float param) { ForEachVoice(cutoff=param); } - void processResonance(float param) + void setResonance(float param) { - ForEachVoice(res = linsc(param,0, 0.991)); + ForEachVoice(res = linsc(param,0, 0.991f)); } - void processResponse(float param) + void setResponse(float param) { // Pole count 1 .. 4 (continuous) ForEachVoice(flt.setResponse(4 - param)); } - void processOversampling(float param) + void setOversampling(float param) { synth.SetOversample(roundToInt(param)); } - void processFilterEnvelopeAmt(float param) + void setFilterEnvelopeAmt(float param) { // Linearly scaled to (+/-) 0..70 semitones - ForEachVoice(fenvamt = linsc(param,0,70)); + ForEachVoice(fenvamt = linsc(param, 0, 70)); } - void processLoudnessEnvelopeAttack(float param) + void setLoudnessEnvelopeAttack(float param) { - ForEachVoice(env.setAttack(timesc(param,1,8500))); + ForEachVoice(env.setAttack(timesc(param, 1, 8500))); } - void processLoudnessEnvelopeDecay(float param) + void setLoudnessEnvelopeDecay(float param) { - ForEachVoice(env.setDecay(timesc(param,1,8500))); + ForEachVoice(env.setDecay(timesc(param, 1, 8500))); } - void processLoudnessEnvelopeSustainTime(float param) + void setLoudnessEnvelopeSustainTime(float param) { - ForEachVoice(env.setSustainTime(timesc(param,1,8500))); + ForEachVoice(env.setSustainTime(timesc(param, 1, 8500))); // When time is set to 1.0, sustain time is infinite - ForEachVoice(env.setAdsr(param > 0.991)); + ForEachVoice(env.setAdsr(param > 9.91f)); } - void processLoudnessEnvelopeRelease(float param) + void setLoudnessEnvelopeRelease(float param) { - ForEachVoice(env.setRelease(timesc(param,1,8500))); + ForEachVoice(env.setRelease(timesc(param, 1, 8500))); } - void processLoudnessEnvelopeSustain(float param) + void setLoudnessEnvelopeSustain(float param) { - ForEachVoice(env.setSustain(param)); + ForEachVoice(env.setSustain(param * 0.1f)); } - void processFilterEnvelopeAttack(float param) + void setFilterEnvelopeAttack(float param) { - ForEachVoice(fenv.setAttack(timesc(param,1,8500))); + ForEachVoice(fenv.setAttack(timesc(param, 1, 8500))); } - void processFilterEnvelopeDecay(float param) + void setFilterEnvelopeDecay(float param) { - ForEachVoice(fenv.setDecay(timesc(param,1,8500))); + ForEachVoice(fenv.setDecay(timesc(param, 1, 8500))); } - void processFilterEnvelopeSustainTime(float param) + void setFilterEnvelopeSustainTime(float param) { - ForEachVoice(fenv.setSustainTime(timesc(param,1,8500))); + ForEachVoice(fenv.setSustainTime(timesc(param, 1, 8500))); // When time is set to 1.0, sustain time is infinite - ForEachVoice(fenv.setAdsr(param > 0.991)); + ForEachVoice(fenv.setAdsr(param > 9.91f)); } - void processFilterEnvelopeRelease(float param) + void setFilterEnvelopeRelease(float param) { - ForEachVoice(fenv.setRelease(timesc(param,1,8500))); + ForEachVoice(fenv.setRelease(timesc(param, 1, 8500))); } - void processFilterEnvelopeSustain(float param) + void setFilterEnvelopeSustain(float param) { - ForEachVoice(fenv.setSustain(param)); + ForEachVoice(fenv.setSustain(param * 0.1f)); } - void processEnvelopeSpread(float param) + void setEnvelopeSpread(float param) { - ForEachVoice(setEnvSpreadAmt(linsc(param,0.0,1))); + ForEachVoice(setEnvSpreadAmt(linsc(param, 0.0, 1.0))); } - void processLfoSpread(float param) + void setLfoSpread(float param) { - ForEachVoice(setLfoSpreadAmt(linsc(param,0.0,1))); + ForEachVoice(setLfoSpreadAmt(linsc(param, 0, 1))); } - void processFilterSpread(float param) + void setFilterSpread(float param) { - ForEachVoice(FltSpreadAmt = linsc(param,0.0,18)); + ForEachVoice(FltSpreadAmt = linsc(param, 0, 18)); } - void processPortamentoSpread(float param) + void setPortamentoSpread(float param) { - ForEachVoice(PortaSpreadAmt = linsc(param,0.0,0.75)); + ForEachVoice(PortaSpreadAmt = linsc(param, 0.0, 0.75)); } - void processLoudnessSpread(float param) + void setLoudnessSpread(float param) { - ForEachVoice(levelSpreadAmt = linsc(param,0.0,0.67)); + ForEachVoice(levelSpreadAmt = linsc(param, 0.0, 0.67)); } - void procOscKeySync(float param) + void setOscKeySync(float param) { ForEachVoice(oscKeySync = roundToInt(param)); } - void procEnvRst(float param) + void setEnvRst(float param) { ForEachVoice(envRst = roundToInt(param)); } diff --git a/plugins/mimid/Engine/Voice.h b/plugins/mimid/Engine/Voice.h index f075c13..6ef2a4e 100644 --- a/plugins/mimid/Engine/Voice.h +++ b/plugins/mimid/Engine/Voice.h @@ -330,7 +330,7 @@ class Voice } void setHPFfreq(float val) { - hpffreq = logsc(val, 4, 2500); + hpffreq = val; hpfcutoff = tan(hpffreq * sampleRateInv * pi); } void setEnvSpreadAmt(float d)