commit 70c52be7b9476e47f410d6235f3a0239224bcb37
parent 9eed9d8d4fecd171e08ca33dea56bdf5b3ff512c
Author: Matt Demanett <matt@demanett.net>
Date: Sat, 18 May 2019 18:52:32 -0400
v1: gets/sets on params, inputs, outputs.
Diffstat:
53 files changed, 719 insertions(+), 719 deletions(-)
diff --git a/src/AD.cpp b/src/AD.cpp
@@ -18,9 +18,9 @@ void AD::onSampleRateChange() {
}
void AD::process(const ProcessArgs& args) {
- lights[LOOP_LIGHT].value = _loopMode = params[LOOP_PARAM].value > 0.5f;
- lights[LINEAR_LIGHT].value = _linearMode = params[LINEAR_PARAM].value > 0.5f;
- if (!(outputs[ENV_OUTPUT].active || outputs[EOC_OUTPUT].active || inputs[TRIGGER_INPUT].active)) {
+ lights[LOOP_LIGHT].value = _loopMode = params[LOOP_PARAM].getValue() > 0.5f;
+ lights[LINEAR_LIGHT].value = _linearMode = params[LINEAR_PARAM].getValue() > 0.5f;
+ if (!(outputs[ENV_OUTPUT].isConnected() || outputs[EOC_OUTPUT].isConnected() || inputs[TRIGGER_INPUT].isConnected())) {
return;
}
@@ -28,33 +28,33 @@ void AD::process(const ProcessArgs& args) {
if (_modulationStep >= modulationSteps) {
_modulationStep = 0;
- float attack = powf(params[ATTACK_PARAM].value, 2.0f);
- if (inputs[ATTACK_INPUT].active) {
- attack *= clamp(inputs[ATTACK_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float attack = powf(params[ATTACK_PARAM].getValue(), 2.0f);
+ if (inputs[ATTACK_INPUT].isConnected()) {
+ attack *= clamp(inputs[ATTACK_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
_envelope.setAttack(_attackSL.next(attack * 10.f));
- float decay = powf(params[DECAY_PARAM].value, 2.0f);
- if (inputs[DECAY_INPUT].active) {
- decay *= clamp(inputs[DECAY_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float decay = powf(params[DECAY_PARAM].getValue(), 2.0f);
+ if (inputs[DECAY_INPUT].isConnected()) {
+ decay *= clamp(inputs[DECAY_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
_envelope.setDecay(_decaySL.next(decay * 10.f));
_envelope.setLinearShape(_linearMode);
}
- _trigger.process(inputs[TRIGGER_INPUT].value);
+ _trigger.process(inputs[TRIGGER_INPUT].getVoltage());
if (!_on && (_trigger.isHigh() || (_loopMode && _envelope.isStage(ADSR::STOPPED_STAGE)))) {
_on = true;
}
_envelope.setGate(_on);
- outputs[ENV_OUTPUT].value = _envelope.next() * 10.0f;
+ outputs[ENV_OUTPUT].setVoltage(_envelope.next() * 10.0f);
if (_on && _envelope.isStage(ADSR::SUSTAIN_STAGE)) {
_envelope.reset();
_on = false;
_eocPulseGen.trigger(0.001f);
}
- outputs[EOC_OUTPUT].value = _eocPulseGen.process(APP->engine->getSampleTime()) ? 5.0f : 0.0f;
+ outputs[EOC_OUTPUT].setVoltage(_eocPulseGen.process(APP->engine->getSampleTime()) ? 5.0f : 0.0f);
lights[ATTACK_LIGHT].value = _envelope.isStage(ADSR::ATTACK_STAGE);
lights[DECAY_LIGHT].value = _envelope.isStage(ADSR::DECAY_STAGE);
diff --git a/src/ADSR.cpp b/src/ADSR.cpp
@@ -13,8 +13,8 @@ void ADSR::onSampleRateChange() {
}
void ADSR::process(const ProcessArgs& args) {
- lights[LINEAR_LIGHT].value = _linearMode = params[LINEAR_PARAM].value > 0.5f;
- if (!(outputs[OUT_OUTPUT].active || inputs[GATE_INPUT].active)) {
+ lights[LINEAR_LIGHT].value = _linearMode = params[LINEAR_PARAM].getValue() > 0.5f;
+ if (!(outputs[OUT_OUTPUT].isConnected() || inputs[GATE_INPUT].isConnected())) {
return;
}
@@ -22,16 +22,16 @@ void ADSR::process(const ProcessArgs& args) {
if (_modulationStep >= modulationSteps) {
_modulationStep = 0;
- _envelope.setAttack(powf(params[ATTACK_PARAM].value, 2.0f) * 10.f);
- _envelope.setDecay(powf(params[DECAY_PARAM].value, 2.0f) * 10.f);
- _envelope.setSustain(params[SUSTAIN_PARAM].value);
- _envelope.setRelease(powf(params[RELEASE_PARAM].value, 2.0f) * 10.f);
+ _envelope.setAttack(powf(params[ATTACK_PARAM].getValue(), 2.0f) * 10.f);
+ _envelope.setDecay(powf(params[DECAY_PARAM].getValue(), 2.0f) * 10.f);
+ _envelope.setSustain(params[SUSTAIN_PARAM].getValue());
+ _envelope.setRelease(powf(params[RELEASE_PARAM].getValue(), 2.0f) * 10.f);
_envelope.setLinearShape(_linearMode);
}
- _gateTrigger.process(inputs[GATE_INPUT].value);
+ _gateTrigger.process(inputs[GATE_INPUT].getVoltage());
_envelope.setGate(_gateTrigger.isHigh());
- outputs[OUT_OUTPUT].value = _envelope.next() * 10.0f;
+ outputs[OUT_OUTPUT].setVoltage(_envelope.next() * 10.0f);
lights[ATTACK_LIGHT].value = _envelope.isStage(bogaudio::dsp::ADSR::ATTACK_STAGE);
lights[DECAY_LIGHT].value = _envelope.isStage(bogaudio::dsp::ADSR::DECAY_STAGE);
diff --git a/src/AMRM.cpp b/src/AMRM.cpp
@@ -2,33 +2,33 @@
#include "AMRM.hpp"
void AMRM::process(const ProcessArgs& args) {
- if (!(outputs[OUT_OUTPUT].active || outputs[RECTIFY_OUTPUT].active)) {
+ if (!(outputs[OUT_OUTPUT].isConnected() || outputs[RECTIFY_OUTPUT].isConnected())) {
return;
}
- float rectify = params[RECTIFY_PARAM].value;
- if (inputs[RECTIFY_INPUT].active) {
- rectify = clamp(rectify + inputs[RECTIFY_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float rectify = params[RECTIFY_PARAM].getValue();
+ if (inputs[RECTIFY_INPUT].isConnected()) {
+ rectify = clamp(rectify + inputs[RECTIFY_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
rectify = 1.0f - rectify;
- float depth = params[DRYWET_PARAM].value;
- if (inputs[DRYWET_INPUT].active) {
- depth = clamp(depth + inputs[DRYWET_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float depth = params[DRYWET_PARAM].getValue();
+ if (inputs[DRYWET_INPUT].isConnected()) {
+ depth = clamp(depth + inputs[DRYWET_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
- float modulator = inputs[MODULATOR_INPUT].value;
+ float modulator = inputs[MODULATOR_INPUT].getVoltage();
if (rectify < 1.0f) {
rectify *= -5.0f;
if (modulator < rectify) {
modulator = rectify - (modulator - rectify);
}
}
- outputs[RECTIFY_OUTPUT].value = modulator;
+ outputs[RECTIFY_OUTPUT].setVoltage(modulator);
modulator *= depth;
modulator += (1.0f - depth) * 5.0f;
- outputs[OUT_OUTPUT].value = _saturator.next(modulator * inputs[CARRIER_INPUT].value * 0.2f);
+ outputs[OUT_OUTPUT].setVoltage(_saturator.next(modulator * inputs[CARRIER_INPUT].getVoltage() * 0.2f));
}
struct AMRMWidget : ModuleWidget {
diff --git a/src/Additator.cpp b/src/Additator.cpp
@@ -44,8 +44,8 @@ float Additator::cvValue(Input& cv, bool dc) {
}
void Additator::process(const ProcessArgs& args) {
- if (!outputs[AUDIO_OUTPUT].active) {
- Phase phase = params[PHASE_PARAM].value > 1.5f ? PHASE_COSINE : PHASE_SINE;
+ if (!outputs[AUDIO_OUTPUT].isConnected()) {
+ Phase phase = params[PHASE_PARAM].getValue() > 1.5f ? PHASE_COSINE : PHASE_SINE;
lights[SINE_LIGHT].value = phase == PHASE_SINE;
lights[COSINE_LIGHT].value = phase == PHASE_COSINE;
return;
@@ -57,9 +57,9 @@ void Additator::process(const ProcessArgs& args) {
if (_steps >= modulationSteps) {
_steps = 0;
- float width = _widthSL.next(clamp(params[WIDTH_PARAM].value + (maxWidth / 2.0f) * cvValue(inputs[WIDTH_INPUT]), 0.0f, maxWidth));
- float oddSkew = _oddSkewSL.next(clamp(params[ODD_SKEW_PARAM].value + cvValue(inputs[ODD_SKEW_INPUT]), -maxSkew, maxSkew));
- float evenSkew = _evenSkewSL.next(clamp(params[EVEN_SKEW_PARAM].value + cvValue(inputs[EVEN_SKEW_INPUT]), -maxSkew, maxSkew));
+ float width = _widthSL.next(clamp(params[WIDTH_PARAM].getValue() + (maxWidth / 2.0f) * cvValue(inputs[WIDTH_INPUT]), 0.0f, maxWidth));
+ float oddSkew = _oddSkewSL.next(clamp(params[ODD_SKEW_PARAM].getValue() + cvValue(inputs[ODD_SKEW_INPUT]), -maxSkew, maxSkew));
+ float evenSkew = _evenSkewSL.next(clamp(params[EVEN_SKEW_PARAM].getValue() + cvValue(inputs[EVEN_SKEW_INPUT]), -maxSkew, maxSkew));
if (
_width != width ||
_oddSkew != oddSkew ||
@@ -86,11 +86,11 @@ void Additator::process(const ProcessArgs& args) {
}
}
- int partials = clamp((int)roundf(params[PARTIALS_PARAM].value * cvValue(inputs[PARTIALS_INPUT], true)), 0, maxPartials);
- float amplitudeNormalization = _amplitudeNormalizationSL.next(clamp(params[GAIN_PARAM].value + ((maxAmplitudeNormalization - minAmplitudeNormalization) / 2.0f) * cvValue(inputs[GAIN_INPUT]), minAmplitudeNormalization, maxAmplitudeNormalization));
- float decay = _decaySL.next(clamp(params[DECAY_PARAM].value + ((maxDecay - minDecay) / 2.0f) * cvValue(inputs[DECAY_INPUT]), minDecay, maxDecay));
- float balance = _balanceSL.next(clamp(params[BALANCE_PARAM].value + cvValue(inputs[BALANCE_INPUT]), -1.0f, 1.0f));
- float filter = _filterSL.next(clamp(params[FILTER_PARAM].value + cvValue(inputs[FILTER_INPUT]), minFilter, maxFilter));
+ int partials = clamp((int)roundf(params[PARTIALS_PARAM].getValue() * cvValue(inputs[PARTIALS_INPUT], true)), 0, maxPartials);
+ float amplitudeNormalization = _amplitudeNormalizationSL.next(clamp(params[GAIN_PARAM].getValue() + ((maxAmplitudeNormalization - minAmplitudeNormalization) / 2.0f) * cvValue(inputs[GAIN_INPUT]), minAmplitudeNormalization, maxAmplitudeNormalization));
+ float decay = _decaySL.next(clamp(params[DECAY_PARAM].getValue() + ((maxDecay - minDecay) / 2.0f) * cvValue(inputs[DECAY_INPUT]), minDecay, maxDecay));
+ float balance = _balanceSL.next(clamp(params[BALANCE_PARAM].getValue() + cvValue(inputs[BALANCE_INPUT]), -1.0f, 1.0f));
+ float filter = _filterSL.next(clamp(params[FILTER_PARAM].getValue() + cvValue(inputs[FILTER_INPUT]), minFilter, maxFilter));
if (
_partials != partials ||
_amplitudeNormalization != amplitudeNormalization ||
@@ -135,25 +135,25 @@ void Additator::process(const ProcessArgs& args) {
}
}
- float frequency = params[FREQUENCY_PARAM].value;
- frequency += params[FINE_PARAM].value / 12.0f;;
- if (inputs[PITCH_INPUT].active) {
- frequency += clamp(inputs[PITCH_INPUT].value, -5.0f, 5.0f);
+ float frequency = params[FREQUENCY_PARAM].getValue();
+ frequency += params[FINE_PARAM].getValue() / 12.0f;;
+ if (inputs[PITCH_INPUT].isConnected()) {
+ frequency += clamp(inputs[PITCH_INPUT].getVoltage(), -5.0f, 5.0f);
}
frequency = clamp(cvToFrequency(frequency), 20.0f, _maxFrequency);
_oscillator.setFrequency(frequency);
- Phase phase = params[PHASE_PARAM].value > 1.5f ? PHASE_COSINE : PHASE_SINE;
+ Phase phase = params[PHASE_PARAM].getValue() > 1.5f ? PHASE_COSINE : PHASE_SINE;
if (_phase != phase) {
_phase = phase;
_oscillator.syncToPhase(_phase == PHASE_SINE ? 0.0f : M_PI / 2.0f);
}
}
- if (_syncTrigger.next(inputs[SYNC_INPUT].value)) {
+ if (_syncTrigger.next(inputs[SYNC_INPUT].getVoltage())) {
_oscillator.syncToPhase(_phase == PHASE_SINE ? 0.0f : M_PI / 2.0f);
}
- outputs[AUDIO_OUTPUT].value = _oscillator.next() * 5.0;
+ outputs[AUDIO_OUTPUT].setVoltage(_oscillator.next() * 5.0);
}
struct AdditatorWidget : ModuleWidget {
diff --git a/src/AddrSeq.cpp b/src/AddrSeq.cpp
@@ -27,20 +27,20 @@ void AddrSeq::dataFromJson(json_t* root) {
}
void AddrSeq::process(const ProcessArgs& args) {
- bool reset = _reset.process(inputs[RESET_INPUT].value);
+ bool reset = _reset.process(inputs[RESET_INPUT].getVoltage());
if (reset) {
_timer.reset();
}
bool timer = _timer.next();
- bool clock = _clock.process(inputs[CLOCK_INPUT].value) && !timer;
+ bool clock = _clock.process(inputs[CLOCK_INPUT].getVoltage()) && !timer;
- int steps = clamp(params[STEPS_PARAM].value, 1.0f, 8.0f);
- int reverse = 1 - 2 * (params[DIRECTION_PARAM].value == 0.0f);
+ int steps = clamp(params[STEPS_PARAM].getValue(), 1.0f, 8.0f);
+ int reverse = 1 - 2 * (params[DIRECTION_PARAM].getValue() == 0.0f);
_step = (_step + reverse * clock) % steps;
_step += (_step < 0) * steps;
_step -= _step * reset;
- int select = params[SELECT_PARAM].value;
- select += clamp(inputs[SELECT_INPUT].value, 0.0f, 10.0f) * 0.1f * 8.0f;
+ int select = params[SELECT_PARAM].getValue();
+ select += clamp(inputs[SELECT_INPUT].getVoltage(), 0.0f, 10.0f) * 0.1f * 8.0f;
if (!_selectOnClock || clock) {
_select = select;
}
@@ -49,10 +49,10 @@ void AddrSeq::process(const ProcessArgs& args) {
float out = 0.0f;
for (int i = 0; i < 8; ++i) {
- out += params[OUT1_PARAM + i].value * (step == i);
+ out += params[OUT1_PARAM + i].getValue() * (step == i);
lights[OUT1_LIGHT + i].value = step == i;
}
- outputs[OUT_OUTPUT].value = out * 10.0f;
+ outputs[OUT_OUTPUT].setVoltage(out * 10.0f);
}
struct SelectOnClockMenuItem : MenuItem {
diff --git a/src/Analyzer.cpp b/src/Analyzer.cpp
@@ -31,7 +31,7 @@ void Analyzer::process(const ProcessArgs& args) {
if (_modulationStep >= modulationSteps) {
_modulationStep = 0;
- float range = params[RANGE2_PARAM].value;
+ float range = params[RANGE2_PARAM].getValue();
_rangeMinHz = 0.0f;
_rangeMaxHz = 0.5f * APP->engine->getSampleRate();
if (range < 0.0f) {
@@ -45,23 +45,23 @@ void Analyzer::process(const ProcessArgs& args) {
}
const float maxTime = 0.5;
- float smooth = params[SMOOTH_PARAM].value * maxTime;
+ float smooth = params[SMOOTH_PARAM].getValue() * maxTime;
smooth /= _core.size() / (_core._overlap * APP->engine->getSampleRate());
int averageN = std::max(1, (int)roundf(smooth));
AnalyzerCore::Quality quality = AnalyzerCore::QUALITY_GOOD;
- if (params[QUALITY_PARAM].value > 2.5) {
+ if (params[QUALITY_PARAM].getValue() > 2.5) {
quality = AnalyzerCore::QUALITY_ULTRA;
}
- else if (params[QUALITY_PARAM].value > 1.5) {
+ else if (params[QUALITY_PARAM].getValue() > 1.5) {
quality = AnalyzerCore::QUALITY_HIGH;
}
AnalyzerCore::Window window = AnalyzerCore::WINDOW_KAISER;
- if (params[WINDOW_PARAM].value > 2.5) {
+ if (params[WINDOW_PARAM].getValue() > 2.5) {
window = AnalyzerCore::WINDOW_NONE;
}
- else if (params[WINDOW_PARAM].value > 1.5) {
+ else if (params[WINDOW_PARAM].getValue() > 1.5) {
window = AnalyzerCore::WINDOW_HAMMING;
}
@@ -70,7 +70,7 @@ void Analyzer::process(const ProcessArgs& args) {
for (int i = 0; i < 4; ++i) {
_core.stepChannel(i, inputs[SIGNALA_INPUT + i]);
- outputs[SIGNALA_OUTPUT + i].value = inputs[SIGNALA_INPUT + i].value;
+ outputs[SIGNALA_OUTPUT + i].setVoltage(inputs[SIGNALA_INPUT + i].getVoltage());
}
lights[QUALITY_ULTRA_LIGHT].value = _core._quality == AnalyzerCore::QUALITY_ULTRA;
diff --git a/src/Blank3.cpp b/src/Blank3.cpp
@@ -6,8 +6,8 @@ void Blank3::onSampleRateChange() {
}
void Blank3::process(const ProcessArgs& args) {
- if (inputs[IN_INPUT].active) {
- _level = _rms.next(inputs[IN_INPUT].value) / 5.0f;
+ if (inputs[IN_INPUT].isConnected()) {
+ _level = _rms.next(inputs[IN_INPUT].getVoltage()) / 5.0f;
}
else {
_level = -1.0f;
diff --git a/src/Blank6.cpp b/src/Blank6.cpp
@@ -6,8 +6,8 @@ void Blank6::onSampleRateChange() {
}
void Blank6::process(const ProcessArgs& args) {
- if (inputs[IN_INPUT].active) {
- _level = _rms.next(inputs[IN_INPUT].value) / 5.0f;
+ if (inputs[IN_INPUT].isConnected()) {
+ _level = _rms.next(inputs[IN_INPUT].getVoltage()) / 5.0f;
}
else {
_level = -1.0f;
diff --git a/src/Bool.cpp b/src/Bool.cpp
@@ -2,13 +2,13 @@
#include "Bool.hpp"
void Bool::process(const ProcessArgs& args) {
- bool a = inputs[A_INPUT].value > 1.0f;
- bool b = inputs[B_INPUT].value > 1.0f;
- outputs[AND_OUTPUT].value = a && b ? 5.0f : 0.0f;
- outputs[OR_OUTPUT].value = a || b ? 5.0f : 0.0f;
- outputs[XOR_OUTPUT].value = a ^ b ? 5.0f : 0.0f;
+ bool a = inputs[A_INPUT].getVoltage() > 1.0f;
+ bool b = inputs[B_INPUT].getVoltage() > 1.0f;
+ outputs[AND_OUTPUT].setVoltage(a && b ? 5.0f : 0.0f);
+ outputs[OR_OUTPUT].setVoltage(a || b ? 5.0f : 0.0f);
+ outputs[XOR_OUTPUT].setVoltage(a ^ b ? 5.0f : 0.0f);
- outputs[NOT_OUTPUT].value = (inputs[NOT_INPUT].active && inputs[NOT_INPUT].value > 1.0f) ? 0.0f : 5.0f;
+ outputs[NOT_OUTPUT].setVoltage((inputs[NOT_INPUT].isConnected() && inputs[NOT_INPUT].getVoltage() > 1.0f) ? 0.0f : 5.0f);
}
struct BoolWidget : ModuleWidget {
diff --git a/src/CVD.cpp b/src/CVD.cpp
@@ -6,11 +6,11 @@ void CVD::onSampleRateChange() {
}
void CVD::process(const ProcessArgs& args) {
- float time = params[TIME_PARAM].value;
- if (inputs[TIME_INPUT].active) {
- time *= clamp(inputs[TIME_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float time = params[TIME_PARAM].getValue();
+ if (inputs[TIME_INPUT].isConnected()) {
+ time *= clamp(inputs[TIME_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
- switch ((int)params[TIME_SCALE_PARAM].value) {
+ switch ((int)params[TIME_SCALE_PARAM].getValue()) {
case 0: {
time /= 100.f;
break;
@@ -22,15 +22,15 @@ void CVD::process(const ProcessArgs& args) {
}
_delay.setTime(time);
- float mix = params[MIX_PARAM].value;
- if (inputs[MIX_INPUT].active) {
- mix = clamp(mix + inputs[MIX_INPUT].value / 5.0f, -1.0f, 1.0f);
+ float mix = params[MIX_PARAM].getValue();
+ if (inputs[MIX_INPUT].isConnected()) {
+ mix = clamp(mix + inputs[MIX_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
}
_mix.setParams(mix);
- float in = inputs[IN_INPUT].value;
+ float in = inputs[IN_INPUT].getVoltage();
float delayed = _delay.next(in);
- outputs[OUT_OUTPUT].value = _mix.next(in, delayed);
+ outputs[OUT_OUTPUT].setVoltage(_mix.next(in, delayed));
}
struct CVDWidget : ModuleWidget {
diff --git a/src/Clpr.cpp b/src/Clpr.cpp
@@ -6,7 +6,7 @@ void Clpr::onReset() {
}
void Clpr::process(const ProcessArgs& args) {
- if (!(outputs[LEFT_OUTPUT].active || outputs[RIGHT_OUTPUT].active)) {
+ if (!(outputs[LEFT_OUTPUT].isConnected() || outputs[RIGHT_OUTPUT].isConnected())) {
return;
}
@@ -14,16 +14,16 @@ void Clpr::process(const ProcessArgs& args) {
if (_modulationStep >= modulationSteps) {
_modulationStep = 0;
- _thresholdDb = params[THRESHOLD_PARAM].value;
- if (inputs[THRESHOLD_INPUT].active) {
- _thresholdDb *= clamp(inputs[THRESHOLD_INPUT].value / 10.0f, 0.0f, 1.0f);
+ _thresholdDb = params[THRESHOLD_PARAM].getValue();
+ if (inputs[THRESHOLD_INPUT].isConnected()) {
+ _thresholdDb *= clamp(inputs[THRESHOLD_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
_thresholdDb *= 30.0f;
_thresholdDb -= 24.0f;
- float outGain = params[OUTPUT_GAIN_PARAM].value;
- if (inputs[OUTPUT_GAIN_INPUT].active) {
- outGain = clamp(outGain + inputs[OUTPUT_GAIN_INPUT].value / 5.0f, 0.0f, 1.0f);
+ float outGain = params[OUTPUT_GAIN_PARAM].getValue();
+ if (inputs[OUTPUT_GAIN_INPUT].isConnected()) {
+ outGain = clamp(outGain + inputs[OUTPUT_GAIN_INPUT].getVoltage() / 5.0f, 0.0f, 1.0f);
}
outGain *= 24.0f;
if (_outGain != outGain) {
@@ -31,20 +31,20 @@ void Clpr::process(const ProcessArgs& args) {
_outLevel = decibelsToAmplitude(_outGain);
}
- _softKnee = params[KNEE_PARAM].value > 0.97f;
+ _softKnee = params[KNEE_PARAM].getValue() > 0.97f;
}
- float leftInput = inputs[LEFT_INPUT].value;
- float rightInput = inputs[RIGHT_INPUT].value;
+ float leftInput = inputs[LEFT_INPUT].getVoltage();
+ float rightInput = inputs[RIGHT_INPUT].getVoltage();
float env = fabsf(leftInput + rightInput);
float detectorDb = amplitudeToDecibels(env / 5.0f);
float compressionDb = _compressor.compressionDb(detectorDb, _thresholdDb, Compressor::maxEffectiveRatio, _softKnee);
_amplifier.setLevel(-compressionDb);
- if (outputs[LEFT_OUTPUT].active) {
- outputs[LEFT_OUTPUT].value = _saturator.next(_amplifier.next(leftInput) * _outLevel);
+ if (outputs[LEFT_OUTPUT].isConnected()) {
+ outputs[LEFT_OUTPUT].setVoltage(_saturator.next(_amplifier.next(leftInput) * _outLevel));
}
- if (outputs[RIGHT_OUTPUT].active) {
- outputs[RIGHT_OUTPUT].value = _saturator.next(_amplifier.next(rightInput) * _outLevel);
+ if (outputs[RIGHT_OUTPUT].isConnected()) {
+ outputs[RIGHT_OUTPUT].setVoltage(_saturator.next(_amplifier.next(rightInput) * _outLevel));
}
}
diff --git a/src/Cmp.cpp b/src/Cmp.cpp
@@ -8,33 +8,33 @@ void Cmp::onReset() {
void Cmp::process(const ProcessArgs& args) {
if (!(
- outputs[GREATER_OUTPUT].active ||
- outputs[LESS_OUTPUT].active ||
- outputs[EQUAL_OUTPUT].active ||
- outputs[NOT_EQUAL_OUTPUT].active
+ outputs[GREATER_OUTPUT].isConnected() ||
+ outputs[LESS_OUTPUT].isConnected() ||
+ outputs[EQUAL_OUTPUT].isConnected() ||
+ outputs[NOT_EQUAL_OUTPUT].isConnected()
)) {
return;
}
- float a = params[A_PARAM].value * 10.0f;
- if (inputs[A_INPUT].active) {
- a = clamp(a + inputs[A_INPUT].value, -12.0f, 12.0f);
+ float a = params[A_PARAM].getValue() * 10.0f;
+ if (inputs[A_INPUT].isConnected()) {
+ a = clamp(a + inputs[A_INPUT].getVoltage(), -12.0f, 12.0f);
}
- float b = params[B_PARAM].value * 10.0f;
- if (inputs[B_INPUT].active) {
- b = clamp(b + inputs[B_INPUT].value, -12.0f, 12.0f);
+ float b = params[B_PARAM].getValue() * 10.0f;
+ if (inputs[B_INPUT].isConnected()) {
+ b = clamp(b + inputs[B_INPUT].getVoltage(), -12.0f, 12.0f);
}
- float window = params[WINDOW_PARAM].value;
- if (inputs[WINDOW_INPUT].active) {
- window *= clamp(inputs[WINDOW_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float window = params[WINDOW_PARAM].getValue();
+ if (inputs[WINDOW_INPUT].isConnected()) {
+ window *= clamp(inputs[WINDOW_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
window *= 10.0f;
float high = 10.0f;
float low = 0.0f;
- if (params[OUTPUT_PARAM].value > 0.5f) {
+ if (params[OUTPUT_PARAM].getValue() > 0.5f) {
high = 5.0f;
low = -5.0f;
}
@@ -146,9 +146,9 @@ void Cmp::stepChannel(
}
int Cmp::lagInSamples() {
- float lag = params[LAG_PARAM].value;
- if (inputs[LAG_INPUT].active) {
- lag *= clamp(inputs[LAG_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float lag = params[LAG_PARAM].getValue();
+ if (inputs[LAG_INPUT].isConnected()) {
+ lag *= clamp(inputs[LAG_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
return lag * lag * APP->engine->getSampleRate();
}
diff --git a/src/DGate.cpp b/src/DGate.cpp
@@ -12,8 +12,8 @@ void DGate::process(const ProcessArgs& args) {
float envelope = 0.0;
bool complete = false;
if (
- _trigger.process(params[TRIGGER_PARAM].value + inputs[TRIGGER_INPUT].value) ||
- (_firstStep && _triggerOnLoad && _shouldTriggerOnLoad && params[LOOP_PARAM].value <= 0.0)
+ _trigger.process(params[TRIGGER_PARAM].getValue() + inputs[TRIGGER_INPUT].getVoltage()) ||
+ (_firstStep && _triggerOnLoad && _shouldTriggerOnLoad && params[LOOP_PARAM].getValue() <= 0.0)
) {
_stage = DELAY_STAGE;
_stageProgress = 0.0;
@@ -33,7 +33,7 @@ void DGate::process(const ProcessArgs& args) {
case GATE_STAGE: {
if (stepStage(params[GATE_PARAM])) {
complete = true;
- if (params[LOOP_PARAM].value <= 0.0 || _trigger.isHigh()) {
+ if (params[LOOP_PARAM].getValue() <= 0.0 || _trigger.isHigh()) {
_stage = DELAY_STAGE;
_stageProgress = 0.0;
}
@@ -49,11 +49,11 @@ void DGate::process(const ProcessArgs& args) {
}
}
- outputs[GATE_OUTPUT].value = envelope * 10.0;
+ outputs[GATE_OUTPUT].setVoltage(envelope * 10.0);
if (complete) {
_triggerOuptutPulseGen.trigger(0.001);
}
- outputs[END_OUTPUT].value = _triggerOuptutPulseGen.process(APP->engine->getSampleTime()) ? 5.0 : 0.0;
+ outputs[END_OUTPUT].setVoltage(_triggerOuptutPulseGen.process(APP->engine->getSampleTime()) ? 5.0 : 0.0);
lights[DELAY_LIGHT].value = _stage == DELAY_STAGE;
lights[GATE_LIGHT].value = _stage == GATE_STAGE;
diff --git a/src/Detune.cpp b/src/Detune.cpp
@@ -2,20 +2,20 @@
#include "Detune.hpp"
void Detune::process(const ProcessArgs& args) {
- if (!(outputs[OUT_PLUS_OUTPUT].active || outputs[OUT_MINUS_OUTPUT].active || outputs[THRU_OUTPUT].active)) {
+ if (!(outputs[OUT_PLUS_OUTPUT].isConnected() || outputs[OUT_MINUS_OUTPUT].isConnected() || outputs[THRU_OUTPUT].isConnected())) {
return;
}
- float cents = params[CENTS_PARAM].value;
- if (inputs[CV_INPUT].active) {
- cents *= clamp(inputs[CV_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float cents = params[CENTS_PARAM].getValue();
+ if (inputs[CV_INPUT].isConnected()) {
+ cents *= clamp(inputs[CV_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
cents = roundf(cents);
}
cents /= 100.0f;
float inCV = 0.0f;
- if (inputs[IN_INPUT].active) {
- inCV = inputs[IN_INPUT].value;
+ if (inputs[IN_INPUT].isConnected()) {
+ inCV = inputs[IN_INPUT].getVoltage();
}
if (_cents != cents || _inCV != inCV) {
@@ -32,9 +32,9 @@ void Detune::process(const ProcessArgs& args) {
}
}
- outputs[THRU_OUTPUT].value = _inCV;
- outputs[OUT_PLUS_OUTPUT].value = _plusCV;
- outputs[OUT_MINUS_OUTPUT].value = _minusCV;
+ outputs[THRU_OUTPUT].setVoltage(_inCV);
+ outputs[OUT_PLUS_OUTPUT].setVoltage(_plusCV);
+ outputs[OUT_MINUS_OUTPUT].setVoltage(_minusCV);
}
struct DetuneWidget : ModuleWidget {
diff --git a/src/EightFO.cpp b/src/EightFO.cpp
@@ -23,16 +23,16 @@ void EightFO::onSampleRateChange() {
}
void EightFO::process(const ProcessArgs& args) {
- lights[SLOW_LIGHT].value = _slowMode = params[SLOW_PARAM].value > 0.5f;
+ lights[SLOW_LIGHT].value = _slowMode = params[SLOW_PARAM].getValue() > 0.5f;
if (!(
- outputs[PHASE7_OUTPUT].active ||
- outputs[PHASE6_OUTPUT].active ||
- outputs[PHASE5_OUTPUT].active ||
- outputs[PHASE4_OUTPUT].active ||
- outputs[PHASE3_OUTPUT].active ||
- outputs[PHASE2_OUTPUT].active ||
- outputs[PHASE1_OUTPUT].active ||
- outputs[PHASE0_OUTPUT].active
+ outputs[PHASE7_OUTPUT].isConnected() ||
+ outputs[PHASE6_OUTPUT].isConnected() ||
+ outputs[PHASE5_OUTPUT].isConnected() ||
+ outputs[PHASE4_OUTPUT].isConnected() ||
+ outputs[PHASE3_OUTPUT].isConnected() ||
+ outputs[PHASE2_OUTPUT].isConnected() ||
+ outputs[PHASE1_OUTPUT].isConnected() ||
+ outputs[PHASE0_OUTPUT].isConnected()
)) {
return;
}
@@ -43,11 +43,11 @@ void EightFO::process(const ProcessArgs& args) {
setFrequency(_slowMode, params[FREQUENCY_PARAM], inputs[PITCH_INPUT], _phasor);
- _wave = (Wave)params[WAVE_PARAM].value;
+ _wave = (Wave)params[WAVE_PARAM].getValue();
if (_wave == SQUARE_WAVE) {
- float pw = params[SAMPLE_PWM_PARAM].value;
- if (inputs[SAMPLE_PWM_INPUT].active) {
- pw *= clamp(inputs[SAMPLE_PWM_INPUT].value / 5.0f, -1.0f, 1.0f);
+ float pw = params[SAMPLE_PWM_PARAM].getValue();
+ if (inputs[SAMPLE_PWM_INPUT].isConnected()) {
+ pw *= clamp(inputs[SAMPLE_PWM_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
}
pw *= 1.0f - 2.0f * _square.minPulseWidth;
pw *= 0.5f;
@@ -56,23 +56,23 @@ void EightFO::process(const ProcessArgs& args) {
_sampleSteps = 1;
}
else {
- float sample = fabsf(params[SAMPLE_PWM_PARAM].value);
- if (inputs[SAMPLE_PWM_INPUT].active) {
- sample *= clamp(fabsf(inputs[SAMPLE_PWM_INPUT].value) / 5.0f, 0.0f, 1.0f);
+ float sample = fabsf(params[SAMPLE_PWM_PARAM].getValue());
+ if (inputs[SAMPLE_PWM_INPUT].isConnected()) {
+ sample *= clamp(fabsf(inputs[SAMPLE_PWM_INPUT].getVoltage()) / 5.0f, 0.0f, 1.0f);
}
float maxSampleSteps = (_phasor._sampleRate / _phasor._frequency) / 4.0f;
_sampleSteps = clamp((int)(sample * maxSampleSteps), 1, (int)maxSampleSteps);
_square.setPulseWidth(SquareOscillator::defaultPulseWidth);
}
- _offset = params[OFFSET_PARAM].value;
- if (inputs[OFFSET_INPUT].active) {
- _offset *= clamp(inputs[OFFSET_INPUT].value / 5.0f, -1.0f, 1.0f);
+ _offset = params[OFFSET_PARAM].getValue();
+ if (inputs[OFFSET_INPUT].isConnected()) {
+ _offset *= clamp(inputs[OFFSET_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
}
_offset *= 5.0f;
- _scale = params[SCALE_PARAM].value;
- if (inputs[SCALE_INPUT].active) {
- _scale *= clamp(inputs[SCALE_INPUT].value / 10.0f, 0.0f, 1.0f);
+ _scale = params[SCALE_PARAM].getValue();
+ if (inputs[SCALE_INPUT].isConnected()) {
+ _scale *= clamp(inputs[SCALE_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
_phase7Offset = phaseOffset(params[PHASE7_PARAM], inputs[PHASE7_INPUT], basePhase7Offset);
@@ -85,7 +85,7 @@ void EightFO::process(const ProcessArgs& args) {
_phase0Offset = phaseOffset(params[PHASE0_PARAM], inputs[PHASE0_INPUT], basePhase0Offset);
}
- if (_resetTrigger.next(inputs[RESET_INPUT].value)) {
+ if (_resetTrigger.next(inputs[RESET_INPUT].getVoltage())) {
_phasor.resetPhase();
}
diff --git a/src/EightOne.cpp b/src/EightOne.cpp
@@ -27,20 +27,20 @@ void EightOne::dataFromJson(json_t* root) {
}
void EightOne::process(const ProcessArgs& args) {
- bool reset = _reset.process(inputs[RESET_INPUT].value);
+ bool reset = _reset.process(inputs[RESET_INPUT].getVoltage());
if (reset) {
_timer.reset();
}
bool timer = _timer.next();
- bool clock = _clock.process(inputs[CLOCK_INPUT].value) && !timer;
+ bool clock = _clock.process(inputs[CLOCK_INPUT].getVoltage()) && !timer;
- int steps = clamp(params[STEPS_PARAM].value, 1.0f, 8.0f);
- int reverse = 1 - 2 * (params[DIRECTION_PARAM].value == 0.0f);
+ int steps = clamp(params[STEPS_PARAM].getValue(), 1.0f, 8.0f);
+ int reverse = 1 - 2 * (params[DIRECTION_PARAM].getValue() == 0.0f);
_step = (_step + reverse * clock) % steps;
_step += (_step < 0) * steps;
_step -= _step * reset;
- int select = params[SELECT_PARAM].value;
- select += clamp(inputs[SELECT_INPUT].value, 0.0f, 10.0f) * 0.1f * 8.0f;
+ int select = params[SELECT_PARAM].getValue();
+ select += clamp(inputs[SELECT_INPUT].getVoltage(), 0.0f, 10.0f) * 0.1f * 8.0f;
if (!_selectOnClock || clock) {
_select = select;
}
@@ -49,10 +49,10 @@ void EightOne::process(const ProcessArgs& args) {
float out = 0.0f;
for (int i = 0; i < 8; ++i) {
- out += inputs[IN1_INPUT + i].value * (step == i);
+ out += inputs[IN1_INPUT + i].getVoltage() * (step == i);
lights[IN1_LIGHT + i].value = step == i;
}
- outputs[OUT_OUTPUT].value = out;
+ outputs[OUT_OUTPUT].setVoltage(out);
}
struct SelectOnClockMenuItem : MenuItem {
diff --git a/src/FMOp.cpp b/src/FMOp.cpp
@@ -37,10 +37,10 @@ void FMOp::dataFromJson(json_t* root) {
}
void FMOp::process(const ProcessArgs& args) {
- if (!outputs[AUDIO_OUTPUT].active) {
- lights[ENV_TO_LEVEL_LIGHT].value = params[ENV_TO_LEVEL_PARAM].value > 0.5f;
- lights[ENV_TO_FEEDBACK_LIGHT].value = params[ENV_TO_FEEDBACK_PARAM].value > 0.5f;
- lights[ENV_TO_DEPTH_LIGHT].value = params[ENV_TO_DEPTH_PARAM].value > 0.5f;
+ if (!outputs[AUDIO_OUTPUT].isConnected()) {
+ lights[ENV_TO_LEVEL_LIGHT].value = params[ENV_TO_LEVEL_PARAM].getValue() > 0.5f;
+ lights[ENV_TO_FEEDBACK_LIGHT].value = params[ENV_TO_FEEDBACK_PARAM].getValue() > 0.5f;
+ lights[ENV_TO_DEPTH_LIGHT].value = params[ENV_TO_DEPTH_PARAM].getValue() > 0.5f;
return;
}
lights[ENV_TO_LEVEL_LIGHT].value = _levelEnvelopeOn;
@@ -48,19 +48,19 @@ void FMOp::process(const ProcessArgs& args) {
lights[ENV_TO_DEPTH_LIGHT].value = _depthEnvelopeOn;
float pitchIn = 0.0f;
- if (inputs[PITCH_INPUT].active) {
- pitchIn = inputs[PITCH_INPUT].value;
+ if (inputs[PITCH_INPUT].isConnected()) {
+ pitchIn = inputs[PITCH_INPUT].getVoltage();
}
float gateIn = 0.0f;
- if (inputs[GATE_INPUT].active) {
- gateIn = inputs[GATE_INPUT].value;
+ if (inputs[GATE_INPUT].isConnected()) {
+ gateIn = inputs[GATE_INPUT].getVoltage();
}
++_steps;
if (_steps >= modulationSteps) {
_steps = 0;
- float ratio = params[RATIO_PARAM].value;
+ float ratio = params[RATIO_PARAM].getValue();
if (ratio < 0.0f) {
ratio = std::max(1.0f + ratio, 0.01f);
}
@@ -69,15 +69,15 @@ void FMOp::process(const ProcessArgs& args) {
ratio += 1.0f;
}
float frequency = pitchIn;
- frequency += params[FINE_PARAM].value / 12.0f;
+ frequency += params[FINE_PARAM].getValue() / 12.0f;
frequency = cvToFrequency(frequency);
frequency *= ratio;
frequency = clamp(frequency, -_maxFrequency, _maxFrequency);
_phasor.setFrequency(frequency / (float)oversample);
- bool levelEnvelopeOn = params[ENV_TO_LEVEL_PARAM].value > 0.5f;
- bool feedbackEnvelopeOn = params[ENV_TO_FEEDBACK_PARAM].value > 0.5f;
- bool depthEnvelopeOn = params[ENV_TO_DEPTH_PARAM].value > 0.5f;
+ bool levelEnvelopeOn = params[ENV_TO_LEVEL_PARAM].getValue() > 0.5f;
+ bool feedbackEnvelopeOn = params[ENV_TO_FEEDBACK_PARAM].getValue() > 0.5f;
+ bool depthEnvelopeOn = params[ENV_TO_DEPTH_PARAM].getValue() > 0.5f;
if (_levelEnvelopeOn != levelEnvelopeOn || _feedbackEnvelopeOn != feedbackEnvelopeOn || _depthEnvelopeOn != depthEnvelopeOn) {
_levelEnvelopeOn = levelEnvelopeOn;
_feedbackEnvelopeOn = feedbackEnvelopeOn;
@@ -89,29 +89,29 @@ void FMOp::process(const ProcessArgs& args) {
_envelopeOn = envelopeOn;
}
if (_envelopeOn) {
- float sustain = params[SUSTAIN_PARAM].value;
- if (inputs[SUSTAIN_INPUT].active) {
- sustain *= clamp(inputs[SUSTAIN_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float sustain = params[SUSTAIN_PARAM].getValue();
+ if (inputs[SUSTAIN_INPUT].isConnected()) {
+ sustain *= clamp(inputs[SUSTAIN_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
- _envelope.setAttack(powf(params[ATTACK_PARAM].value, 2.0f) * 10.f);
- _envelope.setDecay(powf(params[DECAY_PARAM].value, 2.0f) * 10.f);
+ _envelope.setAttack(powf(params[ATTACK_PARAM].getValue(), 2.0f) * 10.f);
+ _envelope.setDecay(powf(params[DECAY_PARAM].getValue(), 2.0f) * 10.f);
_envelope.setSustain(_sustainSL.next(sustain));
- _envelope.setRelease(powf(params[RELEASE_PARAM].value, 2.0f) * 10.f);
+ _envelope.setRelease(powf(params[RELEASE_PARAM].getValue(), 2.0f) * 10.f);
}
- _feedback = params[FEEDBACK_PARAM].value;
- if (inputs[FEEDBACK_INPUT].active) {
- _feedback *= clamp(inputs[FEEDBACK_INPUT].value / 10.0f, 0.0f, 1.0f);
+ _feedback = params[FEEDBACK_PARAM].getValue();
+ if (inputs[FEEDBACK_INPUT].isConnected()) {
+ _feedback *= clamp(inputs[FEEDBACK_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
- _depth = params[DEPTH_PARAM].value;
- if (inputs[DEPTH_INPUT].active) {
- _depth *= clamp(inputs[DEPTH_INPUT].value / 10.0f, 0.0f, 1.0f);
+ _depth = params[DEPTH_PARAM].getValue();
+ if (inputs[DEPTH_INPUT].isConnected()) {
+ _depth *= clamp(inputs[DEPTH_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
- _level = params[LEVEL_PARAM].value;
- if (inputs[LEVEL_INPUT].active) {
- _level *= clamp(inputs[LEVEL_INPUT].value / 10.0f, 0.0f, 1.0f);
+ _level = params[LEVEL_PARAM].getValue();
+ if (inputs[LEVEL_INPUT].isConnected()) {
+ _level *= clamp(inputs[LEVEL_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
}
@@ -138,12 +138,12 @@ void FMOp::process(const ProcessArgs& args) {
offset = feedback * _feedbackDelayedSample;
}
- if (inputs[FM_INPUT].active) {
+ if (inputs[FM_INPUT].isConnected()) {
float depth = _depthSL.next(_depth);
if (_depthEnvelopeOn) {
depth *= envelope;
}
- offset += inputs[FM_INPUT].value * depth * 2.0f;
+ offset += inputs[FM_INPUT].getVoltage() * depth * 2.0f;
}
float sample = 0.0f;
@@ -185,7 +185,7 @@ void FMOp::process(const ProcessArgs& args) {
_phasor.advancePhase(oversample);
}
- outputs[AUDIO_OUTPUT].value = _feedbackDelayedSample = amplitude * sample;
+ outputs[AUDIO_OUTPUT].setVoltage(_feedbackDelayedSample = amplitude * sample);
}
struct LinearLevelMenuItem : MenuItem {
diff --git a/src/Follow.cpp b/src/Follow.cpp
@@ -6,19 +6,19 @@ void Follow::onSampleRateChange() {
}
void Follow::process(const ProcessArgs& args) {
- if (inputs[IN_INPUT].active && outputs[OUT_OUTPUT].active) {
- float response = params[RESPONSE_PARAM].value;
- if (inputs[RESPONSE_INPUT].active) {
- response *= clamp(inputs[RESPONSE_INPUT].value / 10.f, 0.0f, 1.0f);
+ if (inputs[IN_INPUT].isConnected() && outputs[OUT_OUTPUT].isConnected()) {
+ float response = params[RESPONSE_PARAM].getValue();
+ if (inputs[RESPONSE_INPUT].isConnected()) {
+ response *= clamp(inputs[RESPONSE_INPUT].getVoltage() / 10.f, 0.0f, 1.0f);
}
_rms.setSensitivity(response);
- float scale = params[SCALE_PARAM].value;
- if (inputs[SCALE_INPUT].active) {
- scale *= clamp(inputs[SCALE_INPUT].value / 5.0f, -1.0f, 1.0f);
+ float scale = params[SCALE_PARAM].getValue();
+ if (inputs[SCALE_INPUT].isConnected()) {
+ scale *= clamp(inputs[SCALE_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
}
- outputs[OUT_OUTPUT].value = scale * 2.0f * _rms.next(inputs[IN_INPUT].value);
+ outputs[OUT_OUTPUT].setVoltage(scale * 2.0f * _rms.next(inputs[IN_INPUT].getVoltage()));
}
}
diff --git a/src/LFO.cpp b/src/LFO.cpp
@@ -14,13 +14,13 @@ void LFO::onSampleRateChange() {
}
void LFO::process(const ProcessArgs& args) {
- lights[SLOW_LIGHT].value = _slowMode = params[SLOW_PARAM].value > 0.5f;
+ lights[SLOW_LIGHT].value = _slowMode = params[SLOW_PARAM].getValue() > 0.5f;
if (!(
- outputs[SINE_OUTPUT].active ||
- outputs[TRIANGLE_OUTPUT].active ||
- outputs[RAMP_UP_OUTPUT].active ||
- outputs[RAMP_DOWN_OUTPUT].active ||
- outputs[SQUARE_OUTPUT].active
+ outputs[SINE_OUTPUT].isConnected() ||
+ outputs[TRIANGLE_OUTPUT].isConnected() ||
+ outputs[RAMP_UP_OUTPUT].isConnected() ||
+ outputs[RAMP_DOWN_OUTPUT].isConnected() ||
+ outputs[SQUARE_OUTPUT].isConnected()
)) {
return;
}
@@ -31,35 +31,35 @@ void LFO::process(const ProcessArgs& args) {
setFrequency(_slowMode, params[FREQUENCY_PARAM], inputs[PITCH_INPUT], _phasor);
- float pw = params[PW_PARAM].value;
- if (inputs[PW_INPUT].active) {
- pw *= clamp(inputs[PW_INPUT].value / 5.0f, -1.0f, 1.0f);
+ float pw = params[PW_PARAM].getValue();
+ if (inputs[PW_INPUT].isConnected()) {
+ pw *= clamp(inputs[PW_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
}
pw *= 1.0f - 2.0f * _square.minPulseWidth;
pw *= 0.5f;
pw += 0.5f;
_square.setPulseWidth(pw);
- float sample = params[SAMPLE_PARAM].value;
- if (inputs[SAMPLE_INPUT].active) {
- sample *= clamp(inputs[SAMPLE_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float sample = params[SAMPLE_PARAM].getValue();
+ if (inputs[SAMPLE_INPUT].isConnected()) {
+ sample *= clamp(inputs[SAMPLE_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
float maxSampleSteps = (_phasor._sampleRate / _phasor._frequency) / 4.0f;
_sampleSteps = clamp((int)(sample * maxSampleSteps), 1, (int)maxSampleSteps);
- _offset = params[OFFSET_PARAM].value;
- if (inputs[OFFSET_INPUT].active) {
- _offset *= clamp(inputs[OFFSET_INPUT].value / 5.0f, -1.0f, 1.0f);
+ _offset = params[OFFSET_PARAM].getValue();
+ if (inputs[OFFSET_INPUT].isConnected()) {
+ _offset *= clamp(inputs[OFFSET_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
}
_offset *= 5.0f;
- _scale = params[SCALE_PARAM].value;
- if (inputs[SCALE_INPUT].active) {
- _scale *= clamp(inputs[SCALE_INPUT].value / 10.0f, 0.0f, 1.0f);
+ _scale = params[SCALE_PARAM].getValue();
+ if (inputs[SCALE_INPUT].isConnected()) {
+ _scale *= clamp(inputs[SCALE_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
}
- if (_resetTrigger.next(inputs[RESET_INPUT].value)) {
+ if (_resetTrigger.next(inputs[RESET_INPUT].getVoltage())) {
_phasor.resetPhase();
}
diff --git a/src/LLFO.cpp b/src/LLFO.cpp
@@ -12,16 +12,16 @@ void LLFO::onSampleRateChange() {
}
void LLFO::process(const ProcessArgs& args) {
- lights[SLOW_LIGHT].value = _slowMode = params[SLOW_PARAM].value > 0.5f;
+ lights[SLOW_LIGHT].value = _slowMode = params[SLOW_PARAM].getValue() > 0.5f;
- Wave wave = (Wave)params[WAVE_PARAM].value;
+ Wave wave = (Wave)params[WAVE_PARAM].getValue();
lights[SINE_LIGHT].value = wave == SINE_WAVE;
lights[TRIANGLE_LIGHT].value = wave == TRIANGLE_WAVE;
lights[RAMP_UP_LIGHT].value = wave == RAMP_UP_WAVE;
lights[RAMP_DOWN_LIGHT].value = wave == RAMP_DOWN_WAVE;
lights[SQUARE_LIGHT].value = wave == SQUARE_WAVE;
lights[PULSE_LIGHT].value = wave == PULSE_WAVE;
- if (!outputs[OUT_OUTPUT].active) {
+ if (!outputs[OUT_OUTPUT].isConnected()) {
return;
}
@@ -62,11 +62,11 @@ void LLFO::process(const ProcessArgs& args) {
}
}
- _offset = params[OFFSET_PARAM].value * 5.0f;
- _scale = params[SCALE_PARAM].value;
+ _offset = params[OFFSET_PARAM].getValue() * 5.0f;
+ _scale = params[SCALE_PARAM].getValue();
}
- if (_resetTrigger.next(inputs[RESET_INPUT].value)) {
+ if (_resetTrigger.next(inputs[RESET_INPUT].getVoltage())) {
_phasor.resetPhase();
}
_phasor.advancePhase();
@@ -75,7 +75,7 @@ void LLFO::process(const ProcessArgs& args) {
sample = -sample;
}
sample += _offset;
- outputs[OUT_OUTPUT].value = sample;
+ outputs[OUT_OUTPUT].setVoltage(sample);
}
struct LLFOWidget : LFOBaseWidget {
diff --git a/src/Lag.cpp b/src/Lag.cpp
@@ -6,7 +6,7 @@ void Lag::onReset() {
}
void Lag::process(const ProcessArgs& args) {
- if (!(inputs[IN_INPUT].active && outputs[OUT_OUTPUT].active)) {
+ if (!(inputs[IN_INPUT].isConnected() && outputs[OUT_OUTPUT].isConnected())) {
return;
}
@@ -14,11 +14,11 @@ void Lag::process(const ProcessArgs& args) {
if (_modulationStep >= modulationSteps) {
_modulationStep = 0;
- float time = params[TIME_PARAM].value;
- if (inputs[TIME_INPUT].active) {
- time *= clamp(inputs[TIME_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float time = params[TIME_PARAM].getValue();
+ if (inputs[TIME_INPUT].isConnected()) {
+ time *= clamp(inputs[TIME_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
- switch ((int)params[TIME_SCALE_PARAM].value) {
+ switch ((int)params[TIME_SCALE_PARAM].getValue()) {
case 0: {
time /= 10.f;
break;
@@ -30,9 +30,9 @@ void Lag::process(const ProcessArgs& args) {
}
time *= 1000.0f;
- float shape = params[SHAPE_PARAM].value;
- if (inputs[SHAPE_INPUT].active) {
- shape *= clamp(inputs[SHAPE_INPUT].value / 5.0f, -1.0f, 1.0f);
+ float shape = params[SHAPE_PARAM].getValue();
+ if (inputs[SHAPE_INPUT].isConnected()) {
+ shape *= clamp(inputs[SHAPE_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
}
if (shape < 0.0) {
shape = 1.0f + shape;
@@ -46,7 +46,7 @@ void Lag::process(const ProcessArgs& args) {
_slew.setParams(APP->engine->getSampleRate(), time, shape);
}
- outputs[OUT_OUTPUT].value = _slew.next(inputs[IN_INPUT].value);
+ outputs[OUT_OUTPUT].setVoltage(_slew.next(inputs[IN_INPUT].getVoltage()));
}
struct LagWidget : ModuleWidget {
diff --git a/src/Lmtr.cpp b/src/Lmtr.cpp
@@ -14,7 +14,7 @@ void Lmtr::onSampleRateChange() {
}
void Lmtr::process(const ProcessArgs& args) {
- if (!(outputs[LEFT_OUTPUT].active || outputs[RIGHT_OUTPUT].active)) {
+ if (!(outputs[LEFT_OUTPUT].isConnected() || outputs[RIGHT_OUTPUT].isConnected())) {
return;
}
@@ -22,16 +22,16 @@ void Lmtr::process(const ProcessArgs& args) {
if (_modulationStep >= modulationSteps) {
_modulationStep = 0;
- _thresholdDb = params[THRESHOLD_PARAM].value;
- if (inputs[THRESHOLD_INPUT].active) {
- _thresholdDb *= clamp(inputs[THRESHOLD_INPUT].value / 10.0f, 0.0f, 1.0f);
+ _thresholdDb = params[THRESHOLD_PARAM].getValue();
+ if (inputs[THRESHOLD_INPUT].isConnected()) {
+ _thresholdDb *= clamp(inputs[THRESHOLD_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
_thresholdDb *= 30.0f;
_thresholdDb -= 24.0f;
- float outGain = params[OUTPUT_GAIN_PARAM].value;
- if (inputs[OUTPUT_GAIN_INPUT].active) {
- outGain = clamp(outGain + inputs[OUTPUT_GAIN_INPUT].value / 5.0f, 0.0f, 1.0f);
+ float outGain = params[OUTPUT_GAIN_PARAM].getValue();
+ if (inputs[OUTPUT_GAIN_INPUT].isConnected()) {
+ outGain = clamp(outGain + inputs[OUTPUT_GAIN_INPUT].getVoltage() / 5.0f, 0.0f, 1.0f);
}
outGain *= 24.0f;
if (_outGain != outGain) {
@@ -39,11 +39,11 @@ void Lmtr::process(const ProcessArgs& args) {
_outLevel = decibelsToAmplitude(_outGain);
}
- _softKnee = params[KNEE_PARAM].value > 0.97f;
+ _softKnee = params[KNEE_PARAM].getValue() > 0.97f;
}
- float leftInput = inputs[LEFT_INPUT].value;
- float rightInput = inputs[RIGHT_INPUT].value;
+ float leftInput = inputs[LEFT_INPUT].getVoltage();
+ float rightInput = inputs[RIGHT_INPUT].getVoltage();
float env = _detector.next(leftInput + rightInput);
if (env > _lastEnv) {
env = _attackSL.next(env, _lastEnv);
@@ -56,11 +56,11 @@ void Lmtr::process(const ProcessArgs& args) {
float detectorDb = amplitudeToDecibels(env / 5.0f);
float compressionDb = _compressor.compressionDb(detectorDb, _thresholdDb, Compressor::maxEffectiveRatio, _softKnee);
_amplifier.setLevel(-compressionDb);
- if (outputs[LEFT_OUTPUT].active) {
- outputs[LEFT_OUTPUT].value = _saturator.next(_amplifier.next(leftInput) * _outLevel);
+ if (outputs[LEFT_OUTPUT].isConnected()) {
+ outputs[LEFT_OUTPUT].setVoltage(_saturator.next(_amplifier.next(leftInput) * _outLevel));
}
- if (outputs[RIGHT_OUTPUT].active) {
- outputs[RIGHT_OUTPUT].value = _saturator.next(_amplifier.next(rightInput) * _outLevel);
+ if (outputs[RIGHT_OUTPUT].isConnected()) {
+ outputs[RIGHT_OUTPUT].setVoltage(_saturator.next(_amplifier.next(rightInput) * _outLevel));
}
}
diff --git a/src/Manual.cpp b/src/Manual.cpp
@@ -7,7 +7,7 @@ void Manual::onReset() {
}
void Manual::process(const ProcessArgs& args) {
- bool high = _trigger.process(params[TRIGGER_PARAM].value) || _trigger.isHigh() || (_firstStep && _triggerOnLoad && _shouldTriggerOnLoad);
+ bool high = _trigger.process(params[TRIGGER_PARAM].getValue()) || _trigger.isHigh() || (_firstStep && _triggerOnLoad && _shouldTriggerOnLoad);
if (high) {
_pulse.trigger(0.001f);
_pulse.process(APP->engine->getSampleTime());
@@ -17,14 +17,14 @@ void Manual::process(const ProcessArgs& args) {
}
float out = high ? 5.0f : 0.0f;
- outputs[OUT1_OUTPUT].value = out;
- outputs[OUT2_OUTPUT].value = out;
- outputs[OUT3_OUTPUT].value = out;
- outputs[OUT4_OUTPUT].value = out;
- outputs[OUT5_OUTPUT].value = out;
- outputs[OUT6_OUTPUT].value = out;
- outputs[OUT7_OUTPUT].value = out;
- outputs[OUT8_OUTPUT].value = out;
+ outputs[OUT1_OUTPUT].setVoltage(out);
+ outputs[OUT2_OUTPUT].setVoltage(out);
+ outputs[OUT3_OUTPUT].setVoltage(out);
+ outputs[OUT4_OUTPUT].setVoltage(out);
+ outputs[OUT5_OUTPUT].setVoltage(out);
+ outputs[OUT6_OUTPUT].setVoltage(out);
+ outputs[OUT7_OUTPUT].setVoltage(out);
+ outputs[OUT8_OUTPUT].setVoltage(out);
_firstStep = false;
}
diff --git a/src/Matrix88.cpp b/src/Matrix88.cpp
@@ -6,9 +6,9 @@ void Matrix88::process(const ProcessArgs& args) {
int paramOffset = MIX11_PARAM + i * 8;
float out = 0.0f;
for (int j = 0; j < 8; ++j) {
- out += inputs[IN1_INPUT + j].value * params[paramOffset + j].value;
+ out += inputs[IN1_INPUT + j].getVoltage() * params[paramOffset + j].getValue();
}
- outputs[OUT1_OUTPUT + i].value = _saturators[i].next(params[LEVEL_PARAM].value * out);
+ outputs[OUT1_OUTPUT + i].setVoltage(_saturators[i].next(params[LEVEL_PARAM].getValue() * out));
}
}
diff --git a/src/Mix1.cpp b/src/Mix1.cpp
@@ -7,7 +7,7 @@ void Mix1::onSampleRateChange() {
void Mix1::process(const ProcessArgs& args) {
_channel.next(false, false);
- outputs[OUT_OUTPUT].value = _channel.out;
+ outputs[OUT_OUTPUT].setVoltage(_channel.out);
}
struct Mix1Widget : ModuleWidget {
diff --git a/src/Mix4.cpp b/src/Mix4.cpp
@@ -12,22 +12,22 @@ void Mix4::onSampleRateChange() {
}
void Mix4::process(const ProcessArgs& args) {
- bool stereo = outputs[L_OUTPUT].active && outputs[R_OUTPUT].active;
+ bool stereo = outputs[L_OUTPUT].isConnected() && outputs[R_OUTPUT].isConnected();
bool solo =
- params[MUTE1_PARAM].value > 1.5f ||
- params[MUTE2_PARAM].value > 1.5f ||
- params[MUTE3_PARAM].value > 1.5f ||
- params[MUTE4_PARAM].value > 1.5f;
+ params[MUTE1_PARAM].getValue() > 1.5f ||
+ params[MUTE2_PARAM].getValue() > 1.5f ||
+ params[MUTE3_PARAM].getValue() > 1.5f ||
+ params[MUTE4_PARAM].getValue() > 1.5f;
_channel1.next(stereo, solo);
_channel2.next(stereo, solo);
_channel3.next(stereo, solo);
_channel4.next(stereo, solo);
float level = Amplifier::minDecibels;
- if (params[MIX_MUTE_PARAM].value < 0.5f) {
- level = params[MIX_PARAM].value;
- if (inputs[MIX_CV_INPUT].active) {
- level *= clamp(inputs[MIX_CV_INPUT].value / 10.0f, 0.0f, 1.0f);
+ if (params[MIX_MUTE_PARAM].getValue() < 0.5f) {
+ level = params[MIX_PARAM].getValue();
+ if (inputs[MIX_CV_INPUT].isConnected()) {
+ level *= clamp(inputs[MIX_CV_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
level *= MixerChannel::maxDecibels - MixerChannel::minDecibels;
level += MixerChannel::minDecibels;
@@ -51,7 +51,7 @@ void Mix4::process(const ProcessArgs& args) {
left += _channel4.left;
left = _amplifier.next(left);
left = _saturator.next(left);
- outputs[L_OUTPUT].value = left;
+ outputs[L_OUTPUT].setVoltage(left);
float right = 0.0f;
right += _channel1.right;
@@ -60,10 +60,10 @@ void Mix4::process(const ProcessArgs& args) {
right += _channel4.right;
right = _amplifier.next(right);
right = _saturator.next(right);
- outputs[R_OUTPUT].value = right;
+ outputs[R_OUTPUT].setVoltage(right);
}
else {
- outputs[L_OUTPUT].value = outputs[R_OUTPUT].value = mono;
+ outputs[L_OUTPUT].setVoltage(outputs[R_OUTPUT].value = mono);
}
}
diff --git a/src/Mix8.cpp b/src/Mix8.cpp
@@ -16,16 +16,16 @@ _rms.setSampleRate(sr);
}
void Mix8::process(const ProcessArgs& args) {
- bool stereo = outputs[L_OUTPUT].active && outputs[R_OUTPUT].active;
+ bool stereo = outputs[L_OUTPUT].isConnected() && outputs[R_OUTPUT].isConnected();
bool solo =
- params[MUTE1_PARAM].value > 1.5f ||
- params[MUTE2_PARAM].value > 1.5f ||
- params[MUTE3_PARAM].value > 1.5f ||
- params[MUTE4_PARAM].value > 1.5f ||
- params[MUTE5_PARAM].value > 1.5f ||
- params[MUTE6_PARAM].value > 1.5f ||
- params[MUTE7_PARAM].value > 1.5f ||
- params[MUTE8_PARAM].value > 1.5f;
+ params[MUTE1_PARAM].getValue() > 1.5f ||
+ params[MUTE2_PARAM].getValue() > 1.5f ||
+ params[MUTE3_PARAM].getValue() > 1.5f ||
+ params[MUTE4_PARAM].getValue() > 1.5f ||
+ params[MUTE5_PARAM].getValue() > 1.5f ||
+ params[MUTE6_PARAM].getValue() > 1.5f ||
+ params[MUTE7_PARAM].getValue() > 1.5f ||
+ params[MUTE8_PARAM].getValue() > 1.5f;
_channel1.next(stereo, solo);
_channel2.next(stereo, solo);
_channel3.next(stereo, solo);
@@ -36,10 +36,10 @@ void Mix8::process(const ProcessArgs& args) {
_channel8.next(stereo, solo);
float level = Amplifier::minDecibels;
- if (params[MIX_MUTE_PARAM].value < 0.5f) {
- level = params[MIX_PARAM].value;
- if (inputs[MIX_CV_INPUT].active) {
- level *= clamp(inputs[MIX_CV_INPUT].value / 10.0f, 0.0f, 1.0f);
+ if (params[MIX_MUTE_PARAM].getValue() < 0.5f) {
+ level = params[MIX_PARAM].getValue();
+ if (inputs[MIX_CV_INPUT].isConnected()) {
+ level *= clamp(inputs[MIX_CV_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
level *= MixerChannel::maxDecibels - MixerChannel::minDecibels;
level += MixerChannel::minDecibels;
@@ -71,7 +71,7 @@ void Mix8::process(const ProcessArgs& args) {
left += _channel8.left;
left = _amplifier.next(left);
left = _saturator.next(left);
- outputs[L_OUTPUT].value = left;
+ outputs[L_OUTPUT].setVoltage(left);
float right = 0.0f;
right += _channel1.right;
@@ -84,10 +84,10 @@ void Mix8::process(const ProcessArgs& args) {
right += _channel8.right;
right = _amplifier.next(right);
right = _saturator.next(right);
- outputs[R_OUTPUT].value = right;
+ outputs[R_OUTPUT].setVoltage(right);
}
else {
- outputs[L_OUTPUT].value = outputs[R_OUTPUT].value = mono;
+ outputs[L_OUTPUT].setVoltage(outputs[R_OUTPUT].value = mono);
}
}
diff --git a/src/Mult.cpp b/src/Mult.cpp
@@ -2,17 +2,17 @@
#include "Mult.hpp"
void Mult::process(const ProcessArgs& args) {
- float out = inputs[INA_INPUT].value;
- outputs[OUTA1_OUTPUT].value = out;
- outputs[OUTA2_OUTPUT].value = out;
- outputs[OUTA3_OUTPUT].value = out;
+ float out = inputs[INA_INPUT].getVoltage();
+ outputs[OUTA1_OUTPUT].setVoltage(out);
+ outputs[OUTA2_OUTPUT].setVoltage(out);
+ outputs[OUTA3_OUTPUT].setVoltage(out);
- if (inputs[INB_INPUT].active) {
- out = inputs[INB_INPUT].value;
+ if (inputs[INB_INPUT].isConnected()) {
+ out = inputs[INB_INPUT].getVoltage();
}
- outputs[OUTB1_OUTPUT].value = out;
- outputs[OUTB2_OUTPUT].value = out;
- outputs[OUTB3_OUTPUT].value = out;
+ outputs[OUTB1_OUTPUT].setVoltage(out);
+ outputs[OUTB2_OUTPUT].setVoltage(out);
+ outputs[OUTB3_OUTPUT].setVoltage(out);
}
struct MultWidget : ModuleWidget {
diff --git a/src/Mute8.cpp b/src/Mute8.cpp
@@ -22,7 +22,7 @@ void Mute8::onSampleRateChange() {
void Mute8::process(const ProcessArgs& args) {
bool solo = false;
for (int i = 0; i < 8; ++i) {
- solo = solo || params[MUTE1_PARAM + i].value > 1.5f;
+ solo = solo || params[MUTE1_PARAM + i].getValue() > 1.5f;
}
for (int i = 0; i < 8; ++i) {
stepChannel(i, solo);
@@ -30,8 +30,8 @@ void Mute8::process(const ProcessArgs& args) {
}
void Mute8::stepChannel(int i, bool solo) {
- _triggers[i].process(inputs[MUTE1_INPUT + i].value);
- bool muted = solo ? params[MUTE1_PARAM + i].value < 2.0f : (params[MUTE1_PARAM + i].value > 0.5f || _triggers[i].isHigh());
+ _triggers[i].process(inputs[MUTE1_INPUT + i].getVoltage());
+ bool muted = solo ? params[MUTE1_PARAM + i].getValue() < 2.0f : (params[MUTE1_PARAM + i].getValue() > 0.5f || _triggers[i].isHigh());
if (muted) {
lights[MUTE1_LIGHT + i].value = 1.0f;
_amplifiers[i].setLevel(_slewLimiters[i].next(minDecibels));
@@ -40,7 +40,7 @@ void Mute8::stepChannel(int i, bool solo) {
lights[MUTE1_LIGHT + i].value = 0.0f;
_amplifiers[i].setLevel(_slewLimiters[i].next(maxDecibels));
}
- outputs[OUTPUT1_OUTPUT + i].value = _amplifiers[i].next(inputs[INPUT1_INPUT + i].active ? inputs[INPUT1_INPUT + i].value : 5.0f);
+ outputs[OUTPUT1_OUTPUT + i].setVoltage(_amplifiers[i].next(inputs[INPUT1_INPUT + i].isConnected() ? inputs[INPUT1_INPUT + i].getVoltage() : 5.0f));
}
struct Mute8Widget : ModuleWidget {
diff --git a/src/Noise.cpp b/src/Noise.cpp
@@ -2,30 +2,30 @@
#include "Noise.hpp"
void Noise::process(const ProcessArgs& args) {
- if (outputs[BLUE_OUTPUT].active) {
- outputs[BLUE_OUTPUT].value = clamp(_blue.next() * 20.0f, -10.0f, 10.f);
+ if (outputs[BLUE_OUTPUT].isConnected()) {
+ outputs[BLUE_OUTPUT].setVoltage(clamp(_blue.next() * 20.0f, -10.0f, 10.f));
}
- if (outputs[WHITE_OUTPUT].active) {
- outputs[WHITE_OUTPUT].value = clamp(_white.next() * 10.0f, -10.0f, 10.f);
+ if (outputs[WHITE_OUTPUT].isConnected()) {
+ outputs[WHITE_OUTPUT].setVoltage(clamp(_white.next() * 10.0f, -10.0f, 10.f));
}
- if (outputs[PINK_OUTPUT].active) {
- outputs[PINK_OUTPUT].value = clamp(_pink.next() * 15.0f, -10.0f, 10.f);
+ if (outputs[PINK_OUTPUT].isConnected()) {
+ outputs[PINK_OUTPUT].setVoltage(clamp(_pink.next() * 15.0f, -10.0f, 10.f));
}
- if (outputs[RED_OUTPUT].active) {
- outputs[RED_OUTPUT].value = clamp(_red.next() * 20.0f, -10.0f, 10.f);
+ if (outputs[RED_OUTPUT].isConnected()) {
+ outputs[RED_OUTPUT].setVoltage(clamp(_red.next() * 20.0f, -10.0f, 10.f));
}
- if (outputs[GAUSS_OUTPUT].active) {
- outputs[GAUSS_OUTPUT].value = clamp(_gauss.next(), -10.0f, 10.f);
+ if (outputs[GAUSS_OUTPUT].isConnected()) {
+ outputs[GAUSS_OUTPUT].setVoltage(clamp(_gauss.next(), -10.0f, 10.f));
}
float in = 0.0;
- if (inputs[ABS_INPUT].active) {
- in = inputs[ABS_INPUT].value;
+ if (inputs[ABS_INPUT].isConnected()) {
+ in = inputs[ABS_INPUT].getVoltage();
if (in < 0.0) {
in = -in;
}
}
- outputs[ABS_OUTPUT].value = in;
+ outputs[ABS_OUTPUT].setVoltage(in);
}
struct NoiseWidget : ModuleWidget {
diff --git a/src/Nsgt.cpp b/src/Nsgt.cpp
@@ -14,7 +14,7 @@ void Nsgt::onSampleRateChange() {
}
void Nsgt::process(const ProcessArgs& args) {
- if (!(outputs[LEFT_OUTPUT].active || outputs[RIGHT_OUTPUT].active)) {
+ if (!(outputs[LEFT_OUTPUT].isConnected() || outputs[RIGHT_OUTPUT].isConnected())) {
return;
}
@@ -22,16 +22,16 @@ void Nsgt::process(const ProcessArgs& args) {
if (_modulationStep >= modulationSteps) {
_modulationStep = 0;
- _thresholdDb = params[THRESHOLD_PARAM].value;
- if (inputs[THRESHOLD_INPUT].active) {
- _thresholdDb *= clamp(inputs[THRESHOLD_INPUT].value / 10.0f, 0.0f, 1.0f);
+ _thresholdDb = params[THRESHOLD_PARAM].getValue();
+ if (inputs[THRESHOLD_INPUT].isConnected()) {
+ _thresholdDb *= clamp(inputs[THRESHOLD_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
_thresholdDb *= 30.0f;
_thresholdDb -= 24.0f;
- float ratio = params[RATIO_PARAM].value;
- if (inputs[RATIO_INPUT].active) {
- ratio *= clamp(inputs[RATIO_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float ratio = params[RATIO_PARAM].getValue();
+ if (inputs[RATIO_INPUT].isConnected()) {
+ ratio *= clamp(inputs[RATIO_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
if (_ratioKnob != ratio) {
_ratioKnob = ratio;
@@ -43,11 +43,11 @@ void Nsgt::process(const ProcessArgs& args) {
_ratio = 1.0f / _ratio;
}
- _softKnee = params[KNEE_PARAM].value > 0.97f;
+ _softKnee = params[KNEE_PARAM].getValue() > 0.97f;
}
- float leftInput = inputs[LEFT_INPUT].value;
- float rightInput = inputs[RIGHT_INPUT].value;
+ float leftInput = inputs[LEFT_INPUT].getVoltage();
+ float rightInput = inputs[RIGHT_INPUT].getVoltage();
float env = _detector.next(leftInput + rightInput);
if (env > _lastEnv) {
env = _attackSL.next(env, _lastEnv);
@@ -60,11 +60,11 @@ void Nsgt::process(const ProcessArgs& args) {
float detectorDb = amplitudeToDecibels(env / 5.0f);
float compressionDb = _noiseGate.compressionDb(detectorDb, _thresholdDb, _ratio, _softKnee);
_amplifier.setLevel(-compressionDb);
- if (outputs[LEFT_OUTPUT].active) {
- outputs[LEFT_OUTPUT].value = _saturator.next(_amplifier.next(leftInput));
+ if (outputs[LEFT_OUTPUT].isConnected()) {
+ outputs[LEFT_OUTPUT].setVoltage(_saturator.next(_amplifier.next(leftInput)));
}
- if (outputs[RIGHT_OUTPUT].active) {
- outputs[RIGHT_OUTPUT].value = _saturator.next(_amplifier.next(rightInput));
+ if (outputs[RIGHT_OUTPUT].isConnected()) {
+ outputs[RIGHT_OUTPUT].setVoltage(_saturator.next(_amplifier.next(rightInput)));
}
}
diff --git a/src/Offset.cpp b/src/Offset.cpp
@@ -7,13 +7,13 @@ void Offset::process(const ProcessArgs& args) {
scale = scale < 0.0f ? -pow(scale, 2.0f) : pow(scale, 2.0f);
scale *= 10.0;
- float out = inputs[IN_INPUT].value;
+ float out = inputs[IN_INPUT].getVoltage();
out += 10.0f * offset;
out *= scale;
if (!_disableOutputLimit) {
out = clamp(out, -12.0f, 12.0f);
}
- outputs[OUT_OUTPUT].value = out;
+ outputs[OUT_OUTPUT].setVoltage(out);
}
float Offset::knobValue(const Param& knob, const Input& cv) const {
diff --git a/src/OneEight.cpp b/src/OneEight.cpp
@@ -27,29 +27,29 @@ void OneEight::dataFromJson(json_t* root) {
}
void OneEight::process(const ProcessArgs& args) {
- bool reset = _reset.process(inputs[RESET_INPUT].value);
+ bool reset = _reset.process(inputs[RESET_INPUT].getVoltage());
if (reset) {
_timer.reset();
}
bool timer = _timer.next();
- bool clock = _clock.process(inputs[CLOCK_INPUT].value) && !timer;
+ bool clock = _clock.process(inputs[CLOCK_INPUT].getVoltage()) && !timer;
- int steps = clamp(params[STEPS_PARAM].value, 1.0f, 8.0f);
- int reverse = 1 - 2 * (params[DIRECTION_PARAM].value == 0.0f);
+ int steps = clamp(params[STEPS_PARAM].getValue(), 1.0f, 8.0f);
+ int reverse = 1 - 2 * (params[DIRECTION_PARAM].getValue() == 0.0f);
_step = (_step + reverse * clock) % steps;
_step += (_step < 0) * steps;
_step -= _step * reset;
- int select = params[SELECT_PARAM].value;
- select += clamp(inputs[SELECT_INPUT].value, 0.0f, 10.0f) * 0.1f * 8.0f;
+ int select = params[SELECT_PARAM].getValue();
+ select += clamp(inputs[SELECT_INPUT].getVoltage(), 0.0f, 10.0f) * 0.1f * 8.0f;
if (!_selectOnClock || clock) {
_select = select;
}
int step = _step + _select;
step = step % 8;
- float in = inputs[IN_INPUT].value + !inputs[IN_INPUT].active * 10.0f;
+ float in = inputs[IN_INPUT].getVoltage() + !inputs[IN_INPUT].isConnected() * 10.0f;
for (int i = 0; i < 8; ++i) {
- outputs[OUT1_OUTPUT + i].value = (step == i) * in;
+ outputs[OUT1_OUTPUT + i].setVoltage((step == i) * in);
lights[OUT1_LIGHT + i].value = step == i;
}
}
diff --git a/src/Pan.cpp b/src/Pan.cpp
@@ -8,28 +8,28 @@ void Pan::onSampleRateChange() {
}
void Pan::process(const ProcessArgs& args) {
- if (!((inputs[IN1_INPUT].active || inputs[IN2_INPUT].active) && (outputs[L_OUTPUT].active || outputs[R_OUTPUT].active))) {
+ if (!((inputs[IN1_INPUT].isConnected() || inputs[IN2_INPUT].isConnected()) && (outputs[L_OUTPUT].isConnected() || outputs[R_OUTPUT].isConnected()))) {
return;
}
- float pan = params[PAN1_PARAM].value;
- if (inputs[CV1_INPUT].active) {
- pan *= clamp(inputs[CV1_INPUT].value / 5.0f, -1.0f, 1.0f);
+ float pan = params[PAN1_PARAM].getValue();
+ if (inputs[CV1_INPUT].isConnected()) {
+ pan *= clamp(inputs[CV1_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
}
_panner1.setPan(_slew1.next(pan));
- pan = params[PAN2_PARAM].value;
- if (inputs[CV2_INPUT].active) {
- pan *= clamp(inputs[CV2_INPUT].value / 5.0f, -1.0f, 1.0f);
+ pan = params[PAN2_PARAM].getValue();
+ if (inputs[CV2_INPUT].isConnected()) {
+ pan *= clamp(inputs[CV2_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
}
_panner2.setPan(_slew2.next(pan));
float l1 = 0.0f, r1 = 0.0f;
- _panner1.next(inputs[IN1_INPUT].value, l1, r1);
+ _panner1.next(inputs[IN1_INPUT].getVoltage(), l1, r1);
float l2 = 0.0f, r2 = 0.0f;
- _panner2.next(inputs[IN2_INPUT].value, l2, r2);
- outputs[L_OUTPUT].value = _saturatorLeft.next(l1 + l2);
- outputs[R_OUTPUT].value = _saturatorRight.next(r1 + r2);
+ _panner2.next(inputs[IN2_INPUT].getVoltage(), l2, r2);
+ outputs[L_OUTPUT].setVoltage(_saturatorLeft.next(l1 + l2));
+ outputs[R_OUTPUT].setVoltage(_saturatorRight.next(r1 + r2));
}
struct PanWidget : ModuleWidget {
diff --git a/src/Pressor.cpp b/src/Pressor.cpp
@@ -12,12 +12,12 @@ void Pressor::onSampleRateChange() {
void Pressor::process(const ProcessArgs& args) {
if (!(
- outputs[LEFT_OUTPUT].active ||
- outputs[RIGHT_OUTPUT].active ||
- outputs[ENVELOPE_OUTPUT].active ||
- outputs[LEFT_INPUT].active ||
- outputs[RIGHT_INPUT].active ||
- outputs[SIDECHAIN_INPUT].active
+ outputs[LEFT_OUTPUT].isConnected() ||
+ outputs[RIGHT_OUTPUT].isConnected() ||
+ outputs[ENVELOPE_OUTPUT].isConnected() ||
+ outputs[LEFT_INPUT].isConnected() ||
+ outputs[RIGHT_INPUT].isConnected() ||
+ outputs[SIDECHAIN_INPUT].isConnected()
)) {
return;
}
@@ -26,16 +26,16 @@ void Pressor::process(const ProcessArgs& args) {
if (_modulationStep >= modulationSteps) {
_modulationStep = 0;
- _thresholdDb = params[THRESHOLD_PARAM].value;
- if (inputs[THRESHOLD_INPUT].active) {
- _thresholdDb *= clamp(inputs[THRESHOLD_INPUT].value / 10.0f, 0.0f, 1.0f);
+ _thresholdDb = params[THRESHOLD_PARAM].getValue();
+ if (inputs[THRESHOLD_INPUT].isConnected()) {
+ _thresholdDb *= clamp(inputs[THRESHOLD_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
_thresholdDb *= 30.0f;
_thresholdDb -= 24.0f;
- float ratio = params[RATIO_PARAM].value;
- if (inputs[RATIO_INPUT].active) {
- ratio *= clamp(inputs[RATIO_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float ratio = params[RATIO_PARAM].getValue();
+ if (inputs[RATIO_INPUT].isConnected()) {
+ ratio *= clamp(inputs[RATIO_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
if (_ratioKnob != ratio) {
_ratioKnob = ratio;
@@ -48,23 +48,23 @@ void Pressor::process(const ProcessArgs& args) {
}
float sampleRate = APP->engine->getSampleRate();
- float attack = params[ATTACK_PARAM].value;
- if (inputs[ATTACK_INPUT].active) {
- attack *= clamp(inputs[ATTACK_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float attack = params[ATTACK_PARAM].getValue();
+ if (inputs[ATTACK_INPUT].isConnected()) {
+ attack *= clamp(inputs[ATTACK_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
attack *= attack;
_attackSL.setParams(sampleRate, attack * 500.0f);
- float release = params[RELEASE_PARAM].value;
- if (inputs[RELEASE_INPUT].active) {
- release *= clamp(inputs[RELEASE_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float release = params[RELEASE_PARAM].getValue();
+ if (inputs[RELEASE_INPUT].isConnected()) {
+ release *= clamp(inputs[RELEASE_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
release *= release;
_releaseSL.setParams(sampleRate, release * 2000.0f);
- float inGain = params[INPUT_GAIN_PARAM].value;
- if (inputs[INPUT_GAIN_INPUT].active) {
- inGain = clamp(inGain + inputs[INPUT_GAIN_INPUT].value / 5.0f, -1.0f, 1.0f);
+ float inGain = params[INPUT_GAIN_PARAM].getValue();
+ if (inputs[INPUT_GAIN_INPUT].isConnected()) {
+ inGain = clamp(inGain + inputs[INPUT_GAIN_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
}
inGain *= 12.0f;
if (_inGain != inGain) {
@@ -72,9 +72,9 @@ void Pressor::process(const ProcessArgs& args) {
_inLevel = decibelsToAmplitude(_inGain);
}
- float outGain = params[OUTPUT_GAIN_PARAM].value;
- if (inputs[OUTPUT_GAIN_INPUT].active) {
- outGain = clamp(outGain + inputs[OUTPUT_GAIN_INPUT].value / 5.0f, 0.0f, 1.0f);
+ float outGain = params[OUTPUT_GAIN_PARAM].getValue();
+ if (inputs[OUTPUT_GAIN_INPUT].isConnected()) {
+ outGain = clamp(outGain + inputs[OUTPUT_GAIN_INPUT].getVoltage() / 5.0f, 0.0f, 1.0f);
}
outGain *= 24.0f;
if (_outGain != outGain) {
@@ -82,18 +82,18 @@ void Pressor::process(const ProcessArgs& args) {
_outLevel = decibelsToAmplitude(_outGain);
}
- _detectorMix.setParams(params[DETECTOR_MIX_PARAM].value, 0.0f, true);
+ _detectorMix.setParams(params[DETECTOR_MIX_PARAM].getValue(), 0.0f, true);
- _compressorMode = params[MODE_PARAM].value > 0.5f;
- _rmsDetector = params[DECTECTOR_MODE_PARAM].value > 0.5f;
- _softKnee = params[KNEE_PARAM].value > 0.97f;
+ _compressorMode = params[MODE_PARAM].getValue() > 0.5f;
+ _rmsDetector = params[DECTECTOR_MODE_PARAM].getValue() > 0.5f;
+ _softKnee = params[KNEE_PARAM].getValue() > 0.97f;
}
- float leftInput = inputs[LEFT_INPUT].value * _inLevel;
- float rightInput = inputs[RIGHT_INPUT].value * _inLevel;
+ float leftInput = inputs[LEFT_INPUT].getVoltage() * _inLevel;
+ float rightInput = inputs[RIGHT_INPUT].getVoltage() * _inLevel;
float env = leftInput + rightInput;
- if (inputs[SIDECHAIN_INPUT].active) {
- env = _detectorMix.next(env, inputs[SIDECHAIN_INPUT].value);
+ if (inputs[SIDECHAIN_INPUT].isConnected()) {
+ env = _detectorMix.next(env, inputs[SIDECHAIN_INPUT].getVoltage());
}
if (_rmsDetector) {
env = _detectorRMS.next(env);
@@ -117,12 +117,12 @@ void Pressor::process(const ProcessArgs& args) {
_compressionDb = _noiseGate.compressionDb(detectorDb, _thresholdDb, _ratio, _softKnee);
}
_amplifier.setLevel(-_compressionDb);
- outputs[ENVELOPE_OUTPUT].value = env;
- if (outputs[LEFT_OUTPUT].active) {
- outputs[LEFT_OUTPUT].value = _saturator.next(_amplifier.next(leftInput) * _outLevel);
+ outputs[ENVELOPE_OUTPUT].setVoltage(env);
+ if (outputs[LEFT_OUTPUT].isConnected()) {
+ outputs[LEFT_OUTPUT].setVoltage(_saturator.next(_amplifier.next(leftInput) * _outLevel));
}
- if (outputs[RIGHT_OUTPUT].active) {
- outputs[RIGHT_OUTPUT].value = _saturator.next(_amplifier.next(rightInput) * _outLevel);
+ if (outputs[RIGHT_OUTPUT].isConnected()) {
+ outputs[RIGHT_OUTPUT].setVoltage(_saturator.next(_amplifier.next(rightInput) * _outLevel));
}
}
diff --git a/src/Reftone.cpp b/src/Reftone.cpp
@@ -7,30 +7,30 @@ void Reftone::process(const ProcessArgs& args) {
const int referenceOctave = 4;
if (!(
- _pitch == params[PITCH_PARAM].value &&
- _octave == params[OCTAVE_PARAM].value &&
- _fine == params[FINE_PARAM].value
+ _pitch == params[PITCH_PARAM].getValue() &&
+ _octave == params[OCTAVE_PARAM].getValue() &&
+ _fine == params[FINE_PARAM].getValue()
)) {
- _pitch = params[PITCH_PARAM].value;
- _octave = params[OCTAVE_PARAM].value;
- _fine = params[FINE_PARAM].value;
+ _pitch = params[PITCH_PARAM].getValue();
+ _octave = params[OCTAVE_PARAM].getValue();
+ _fine = params[FINE_PARAM].getValue();
_frequency = semitoneToFrequency(referenceSemitone + 12*(_octave - referenceOctave) + (_pitch - referencePitch) + _fine);
_cv = frequencyToCV(_frequency);
}
- if (outputs[CV_OUTPUT].active) {
- outputs[CV_OUTPUT].value = _cv;
+ if (outputs[CV_OUTPUT].isConnected()) {
+ outputs[CV_OUTPUT].setVoltage(_cv);
}
else {
- outputs[CV_OUTPUT].value = 0.0;
+ outputs[CV_OUTPUT].setVoltage(0.0);
}
- if (outputs[OUT_OUTPUT].active) {
+ if (outputs[OUT_OUTPUT].isConnected()) {
_sine.setFrequency(_frequency);
- outputs[OUT_OUTPUT].value = _sine.next() * 5.0f;
+ outputs[OUT_OUTPUT].setVoltage(_sine.next() * 5.0f);
}
else {
- outputs[OUT_OUTPUT].value = 0.0;
+ outputs[OUT_OUTPUT].setVoltage(0.0);
}
}
diff --git a/src/SampleHold.cpp b/src/SampleHold.cpp
@@ -10,31 +10,31 @@ void SampleHold::onReset() {
void SampleHold::process(const ProcessArgs& args) {
{
- lights[TRACK1_LIGHT].value = params[TRACK1_PARAM].value;
- bool triggered = _trigger1.process(params[TRIGGER1_PARAM].value + inputs[TRIGGER1_INPUT].value);
- if (params[TRACK1_PARAM].value > 0.5f ? _trigger1.isHigh() : triggered) {
- if (inputs[IN1_INPUT].active) {
- _value1 = inputs[IN1_INPUT].value;
+ lights[TRACK1_LIGHT].value = params[TRACK1_PARAM].getValue();
+ bool triggered = _trigger1.process(params[TRIGGER1_PARAM].getValue() + inputs[TRIGGER1_INPUT].getVoltage());
+ if (params[TRACK1_PARAM].getValue() > 0.5f ? _trigger1.isHigh() : triggered) {
+ if (inputs[IN1_INPUT].isConnected()) {
+ _value1 = inputs[IN1_INPUT].getVoltage();
}
else {
_value1 = fabsf(_noise.next()) * 10.0;
}
}
- outputs[OUT1_OUTPUT].value = _value1;
+ outputs[OUT1_OUTPUT].setVoltage(_value1);
}
{
- lights[TRACK2_LIGHT].value = params[TRACK2_PARAM].value;
- bool triggered = _trigger2.process(params[TRIGGER2_PARAM].value + inputs[TRIGGER2_INPUT].value);
- if (params[TRACK2_PARAM].value > 0.5f ? _trigger2.isHigh() : triggered) {
- if (inputs[IN2_INPUT].active) {
- _value2 = inputs[IN2_INPUT].value;
+ lights[TRACK2_LIGHT].value = params[TRACK2_PARAM].getValue();
+ bool triggered = _trigger2.process(params[TRIGGER2_PARAM].getValue() + inputs[TRIGGER2_INPUT].getVoltage());
+ if (params[TRACK2_PARAM].getValue() > 0.5f ? _trigger2.isHigh() : triggered) {
+ if (inputs[IN2_INPUT].isConnected()) {
+ _value2 = inputs[IN2_INPUT].getVoltage();
}
else {
_value2 = fabsf(_noise.next()) * 10.0;
}
}
- outputs[OUT2_OUTPUT].value = _value2;
+ outputs[OUT2_OUTPUT].setVoltage(_value2);
}
}
diff --git a/src/Slew.cpp b/src/Slew.cpp
@@ -6,7 +6,7 @@ void Slew::onReset() {
}
void Slew::process(const ProcessArgs& args) {
- if (!(inputs[IN_INPUT].active && outputs[OUT_OUTPUT].active)) {
+ if (!(inputs[IN_INPUT].isConnected() && outputs[OUT_OUTPUT].isConnected())) {
return;
}
@@ -23,20 +23,20 @@ void Slew::process(const ProcessArgs& args) {
_fall.setParams(APP->engine->getSampleRate(), fallTime, fallShape);
}
- float sample = inputs[IN_INPUT].value;
+ float sample = inputs[IN_INPUT].getVoltage();
if (sample > _last) {
if (!_rising) {
_rising = true;
_rise._last = _last;
}
- outputs[OUT_OUTPUT].value = _last = _rise.next(sample);
+ outputs[OUT_OUTPUT].setVoltage(_last = _rise.next(sample));
}
else {
if (_rising) {
_rising = false;
_fall._last = _last;
}
- outputs[OUT_OUTPUT].value = _last = _fall.next(sample);
+ outputs[OUT_OUTPUT].setVoltage(_last = _fall.next(sample));
}
}
diff --git a/src/Stack.cpp b/src/Stack.cpp
@@ -2,26 +2,26 @@
#include "Stack.hpp"
void Stack::process(const ProcessArgs& args) {
- lights[QUANTIZE_LIGHT].value = params[QUANTIZE_PARAM].value > 0.5;
- if (!(outputs[OUT_OUTPUT].active || outputs[THRU_OUTPUT].active)) {
+ lights[QUANTIZE_LIGHT].value = params[QUANTIZE_PARAM].getValue() > 0.5;
+ if (!(outputs[OUT_OUTPUT].isConnected() || outputs[THRU_OUTPUT].isConnected())) {
return;
}
- float semitones = params[OCTAVE_PARAM].value * 12.0;
- semitones += params[SEMIS_PARAM].value;
- if (inputs[CV_INPUT].active) {
- semitones += clamp(inputs[CV_INPUT].value, -5.0f, 5.0f) * 10.0;
+ float semitones = params[OCTAVE_PARAM].getValue() * 12.0;
+ semitones += params[SEMIS_PARAM].getValue();
+ if (inputs[CV_INPUT].isConnected()) {
+ semitones += clamp(inputs[CV_INPUT].getVoltage(), -5.0f, 5.0f) * 10.0;
}
- if (params[QUANTIZE_PARAM].value > 0.5) {
+ if (params[QUANTIZE_PARAM].getValue() > 0.5) {
semitones = roundf(semitones);
}
float inCV = 0.0f;
- if (inputs[IN_INPUT].active) {
- inCV = clamp(inputs[IN_INPUT].value, _minCVOut, _maxCVOut);
+ if (inputs[IN_INPUT].isConnected()) {
+ inCV = clamp(inputs[IN_INPUT].getVoltage(), _minCVOut, _maxCVOut);
}
- float fine = params[FINE_PARAM].value;
+ float fine = params[FINE_PARAM].getValue();
if (_semitones != semitones || _inCV != inCV || _fine != fine) {
_semitones = semitones;
@@ -30,13 +30,13 @@ void Stack::process(const ProcessArgs& args) {
_outCV = clamp(semitoneToCV((_inCV != 0.0f ? cvToSemitone(_inCV) : referenceSemitone) + _semitones + _fine), _minCVOut, _maxCVOut);
}
- if (inputs[IN_INPUT].active) {
- outputs[THRU_OUTPUT].value = _inCV;
+ if (inputs[IN_INPUT].isConnected()) {
+ outputs[THRU_OUTPUT].setVoltage(_inCV);
}
else {
- outputs[THRU_OUTPUT].value = _semitones / 10.0;
+ outputs[THRU_OUTPUT].setVoltage(_semitones / 10.0);
}
- outputs[OUT_OUTPUT].value = _outCV;
+ outputs[OUT_OUTPUT].setVoltage(_outCV);
}
struct StackWidget : ModuleWidget {
diff --git a/src/Sums.cpp b/src/Sums.cpp
@@ -2,32 +2,32 @@
#include "Sums.hpp"
void Sums::process(const ProcessArgs& args) {
- float a = inputs[A_INPUT].value;
- float b = inputs[B_INPUT].value;
+ float a = inputs[A_INPUT].getVoltage();
+ float b = inputs[B_INPUT].getVoltage();
if (_disableOutputLimit) {
outputs[SUM_OUTPUT].value = a + b,
- outputs[DIFFERENCE_OUTPUT].value = a - b;
- outputs[MAX_OUTPUT].value = std::max(a, b);
- outputs[MIN_OUTPUT].value = std::min(a, b);
+ outputs[DIFFERENCE_OUTPUT].setVoltage(a - b);
+ outputs[MAX_OUTPUT].setVoltage(std::max(a, b));
+ outputs[MIN_OUTPUT].setVoltage(std::min(a, b));
- if (inputs[NEGATE_INPUT].active) {
- outputs[NEGATE_OUTPUT].value = -inputs[NEGATE_INPUT].value;
+ if (inputs[NEGATE_INPUT].isConnected()) {
+ outputs[NEGATE_OUTPUT].setVoltage(-inputs[NEGATE_INPUT].getVoltage());
}
else {
- outputs[NEGATE_OUTPUT].value = 0.0f;
+ outputs[NEGATE_OUTPUT].setVoltage(0.0f);
}
}
else {
- outputs[SUM_OUTPUT].value = clamp(a + b, -12.0f, 12.0f);
- outputs[DIFFERENCE_OUTPUT].value = clamp(a - b, -12.0f, 12.0f);
- outputs[MAX_OUTPUT].value = clamp(std::max(a, b), -12.0f, 12.0f);
- outputs[MIN_OUTPUT].value = clamp(std::min(a, b), -12.0f, 12.0f);
+ outputs[SUM_OUTPUT].setVoltage(clamp(a + b, -12.0f, 12.0f));
+ outputs[DIFFERENCE_OUTPUT].setVoltage(clamp(a - b, -12.0f, 12.0f));
+ outputs[MAX_OUTPUT].setVoltage(clamp(std::max(a, b), -12.0f, 12.0f));
+ outputs[MIN_OUTPUT].setVoltage(clamp(std::min(a, b), -12.0f, 12.0f));
- if (inputs[NEGATE_INPUT].active) {
- outputs[NEGATE_OUTPUT].value = clamp(-inputs[NEGATE_INPUT].value, -12.0f, 12.0f);
+ if (inputs[NEGATE_INPUT].isConnected()) {
+ outputs[NEGATE_OUTPUT].setVoltage(clamp(-inputs[NEGATE_INPUT].getVoltage(), -12.0f, 12.0f));
}
else {
- outputs[NEGATE_OUTPUT].value = 0.0f;
+ outputs[NEGATE_OUTPUT].setVoltage(0.0f);
}
}
}
diff --git a/src/Switch.cpp b/src/Switch.cpp
@@ -6,10 +6,10 @@ void bogaudio::Switch::onReset() {
}
void bogaudio::Switch::step() {
- bool latched = params[LATCH_PARAM].value > 0.5f;
+ bool latched = params[LATCH_PARAM].getValue() > 0.5f;
lights[LATCH_LIGHT].value = latched;
- bool triggered = _trigger.process(params[GATE_PARAM].value + inputs[GATE_INPUT].value);
+ bool triggered = _trigger.process(params[GATE_PARAM].getValue() + inputs[GATE_INPUT].getVoltage());
if (latched) {
if (triggered) {
_latchedHigh = !_latchedHigh;
@@ -20,12 +20,12 @@ void bogaudio::Switch::step() {
}
if (_latchedHigh || _trigger.isHigh()) {
- outputs[OUT1_OUTPUT].value = inputs[HIGH1_INPUT].value;
- outputs[OUT2_OUTPUT].value = inputs[HIGH2_INPUT].value;
+ outputs[OUT1_OUTPUT].setVoltage(inputs[HIGH1_INPUT].getVoltage());
+ outputs[OUT2_OUTPUT].setVoltage(inputs[HIGH2_INPUT].getVoltage());
}
else {
- outputs[OUT1_OUTPUT].value = inputs[LOW1_INPUT].value;
- outputs[OUT2_OUTPUT].value = inputs[LOW2_INPUT].value;
+ outputs[OUT1_OUTPUT].setVoltage(inputs[LOW1_INPUT].getVoltage());
+ outputs[OUT2_OUTPUT].setVoltage(inputs[LOW2_INPUT].getVoltage());
}
}
diff --git a/src/Test.cpp b/src/Test.cpp
@@ -5,96 +5,96 @@ void Test::onReset() {
}
void Test::process(const ProcessArgs& args) {
- if (!(outputs[OUT_OUTPUT].active || outputs[OUT2_OUTPUT].active)) {
+ if (!(outputs[OUT_OUTPUT].isConnected() || outputs[OUT2_OUTPUT].isConnected())) {
return;
}
#ifdef LPF
- if (!inputs[IN_INPUT].active) {
+ if (!inputs[IN_INPUT].isConnected()) {
return;
}
_lpf.setParams(
APP->engine->getSampleRate(),
- 10000.0 * clamp(params[PARAM1_PARAM].value, 0.0f, 1.0f),
- std::max(10.0 * clamp(params[PARAM2_PARAM].value, 0.0f, 1.0f), 0.1)
+ 10000.0 * clamp(params[PARAM1_PARAM].getValue(), 0.0f, 1.0f),
+ std::max(10.0 * clamp(params[PARAM2_PARAM].getValue(), 0.0f, 1.0f), 0.1)
);
- outputs[OUT_OUTPUT].value = _lpf.next(inputs[IN_INPUT].value);
+ outputs[OUT_OUTPUT].setVoltage(_lpf.next(inputs[IN_INPUT].getVoltage()));
#elif LPFNOISE
_lpf.setParams(
APP->engine->getSampleRate(),
- 22000.0 * clamp(params[PARAM1_PARAM].value, 0.0f, 1.0f),
+ 22000.0 * clamp(params[PARAM1_PARAM].getValue(), 0.0f, 1.0f),
0.717f
);
float noise = _noise.next();
- outputs[OUT_OUTPUT].value = _lpf.next(noise) * 10.0;;
- outputs[OUT2_OUTPUT].value = noise * 10.0;;
+ outputs[OUT_OUTPUT].setVoltage(_lpf.next(noise) * 10.0);;
+ outputs[OUT2_OUTPUT].setVoltage(noise * 10.0);;
#elif SINE
_sine.setSampleRate(APP->engine->getSampleRate());
_sine.setFrequency(oscillatorPitch());
- outputs[OUT_OUTPUT].value = _sine.next() * 5.0f;
+ outputs[OUT_OUTPUT].setVoltage(_sine.next() * 5.0f);
_sine2.setSampleRate(APP->engine->getSampleRate());
_sine2.setFrequency(oscillatorPitch());
- outputs[OUT2_OUTPUT].value = _sine2.next() * 5.0f;
+ outputs[OUT2_OUTPUT].setVoltage(_sine2.next() * 5.0f);
#elif SQUARE
_square.setSampleRate(APP->engine->getSampleRate());
_square.setFrequency(oscillatorPitch());
- float pw = params[PARAM2_PARAM].value;
- if (inputs[CV2_INPUT].active) {
- pw += clamp(inputs[CV2_INPUT].value, -5.0f, 5.0f) / 10.0f;
+ float pw = params[PARAM2_PARAM].getValue();
+ if (inputs[CV2_INPUT].isConnected()) {
+ pw += clamp(inputs[CV2_INPUT].getVoltage(), -5.0f, 5.0f) / 10.0f;
}
_square.setPulseWidth(pw);
- outputs[OUT_OUTPUT].value = _square.next() * 5.0f;
+ outputs[OUT_OUTPUT].setVoltage(_square.next() * 5.0f);
_square2.setSampleRate(APP->engine->getSampleRate());
_square2.setFrequency(oscillatorPitch());
_square2.setPulseWidth(pw);
- _square2.setQuality(params[PARAM3_PARAM].value * 200);
- outputs[OUT2_OUTPUT].value = _square2.next() * 5.0f;
+ _square2.setQuality(params[PARAM3_PARAM].getValue() * 200);
+ outputs[OUT2_OUTPUT].setVoltage(_square2.next() * 5.0f);
#elif SAW
_saw.setSampleRate(APP->engine->getSampleRate());
_saw.setFrequency(oscillatorPitch());
- outputs[OUT_OUTPUT].value = _saw.next() * 5.0f;
+ outputs[OUT_OUTPUT].setVoltage(_saw.next() * 5.0f);
_saw2.setSampleRate(APP->engine->getSampleRate());
_saw2.setFrequency(oscillatorPitch());
- _saw2.setQuality(params[PARAM2_PARAM].value * 200);
- outputs[OUT2_OUTPUT].value = _saw2.next() * 5.0f;
+ _saw2.setQuality(params[PARAM2_PARAM].getValue() * 200);
+ outputs[OUT2_OUTPUT].setVoltage(_saw2.next() * 5.0f);
#elif SATSAW
- float saturation = params[PARAM2_PARAM].value * 10.0f;
- if (inputs[CV2_INPUT].active) {
- saturation *= clamp(inputs[CV2_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float saturation = params[PARAM2_PARAM].getValue() * 10.0f;
+ if (inputs[CV2_INPUT].isConnected()) {
+ saturation *= clamp(inputs[CV2_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
_saw.setSampleRate(APP->engine->getSampleRate());
_saw.setFrequency(oscillatorPitch());
_saw.setSaturation(saturation);
- outputs[OUT_OUTPUT].value = _saw.next() * 5.0f;
+ outputs[OUT_OUTPUT].setVoltage(_saw.next() * 5.0f);
_saw2.setSampleRate(APP->engine->getSampleRate());
_saw2.setFrequency(oscillatorPitch());
_saw2.setSaturation(saturation);
- _saw2.setQuality(params[PARAM3_PARAM].value * 200);
- outputs[OUT2_OUTPUT].value = _saw2.next() * 5.0f;
+ _saw2.setQuality(params[PARAM3_PARAM].getValue() * 200);
+ outputs[OUT2_OUTPUT].setVoltage(_saw2.next() * 5.0f);
#elif TRIANGLE
_triangle.setSampleRate(APP->engine->getSampleRate());
_triangle.setFrequency(oscillatorPitch());
- outputs[OUT_OUTPUT].value = _triangle.next() * 5.0f;
+ outputs[OUT_OUTPUT].setVoltage(_triangle.next() * 5.0f);
#elif SAMPLED_TRIANGLE
- float sample = params[PARAM2_PARAM].value * Phasor::maxSampleWidth;
- if (inputs[CV2_INPUT].active) {
- sample *= clamp(inputs[CV2_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float sample = params[PARAM2_PARAM].getValue() * Phasor::maxSampleWidth;
+ if (inputs[CV2_INPUT].isConnected()) {
+ sample *= clamp(inputs[CV2_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
_triangle.setSampleRate(APP->engine->getSampleRate());
_triangle.setFrequency(oscillatorPitch());
_triangle.setSampleWidth(sample);
- outputs[OUT_OUTPUT].value = _triangle.next() * 5.0f;
+ outputs[OUT_OUTPUT].setVoltage(_triangle.next() * 5.0f);
_triangle2.setSampleRate(APP->engine->getSampleRate());
_triangle2.setFrequency(oscillatorPitch());
@@ -108,12 +108,12 @@ void Test::process(const ProcessArgs& args) {
else {
_triangle2.advancePhase();
}
- outputs[OUT2_OUTPUT].value = _sample;
+ outputs[OUT2_OUTPUT].setVoltage(_sample);
#elif SINEBANK
_sineBank.setSampleRate(APP->engine->getSampleRate());
_sineBank.setFrequency(oscillatorPitch());
- outputs[OUT_OUTPUT].value = _sineBank.next();
+ outputs[OUT_OUTPUT].setVoltage(_sineBank.next());
#elif OVERSAMPLING
_saw1.setSampleRate(APP->engine->getSampleRate());
@@ -122,7 +122,7 @@ void Test::process(const ProcessArgs& args) {
for (int i = 0; i < OVERSAMPLEN; ++i) {
buf[i] = _saw1.next();
}
- outputs[OUT_OUTPUT].value = _rackDecimator.process(buf) * 5.0f;
+ outputs[OUT_OUTPUT].setVoltage(_rackDecimator.process(buf) * 5.0f);
_saw2.setSampleRate(APP->engine->getSampleRate());
_saw2.setFrequency(oscillatorPitch() / (float)OVERSAMPLEN);
@@ -142,23 +142,23 @@ void Test::process(const ProcessArgs& args) {
s = _lpf.next(_saw2.next());
// s = _saw2.next();
}
- outputs[OUT2_OUTPUT].value = s * 5.0;
+ outputs[OUT2_OUTPUT].setVoltage(s * 5.0);
#elif OVERSAMPLED_BL
- int quality = params[PARAM2_PARAM].value * 100;
+ int quality = params[PARAM2_PARAM].getValue() * 100;
const int maxOversample = 16;
- int oversample = params[PARAM3_PARAM].value * maxOversample;
+ int oversample = params[PARAM3_PARAM].getValue() * maxOversample;
_saw1.setSampleRate(APP->engine->getSampleRate());
_saw1.setFrequency(oscillatorPitch());
_saw1.setQuality(quality);
- outputs[OUT_OUTPUT].value = _saw1.next() * 5.0f;
+ outputs[OUT_OUTPUT].setVoltage(_saw1.next() * 5.0f);
_saw2.setSampleRate(APP->engine->getSampleRate());
_saw2.setQuality(quality);
if (oversample < 2) {
_saw2.setFrequency(oscillatorPitch());
- outputs[OUT2_OUTPUT].value = _saw2.next() * 5.0f;
+ outputs[OUT2_OUTPUT].setVoltage(_saw2.next() * 5.0f);
}
else {
_saw2.setFrequency(oscillatorPitch() / (float)oversample);
@@ -171,7 +171,7 @@ void Test::process(const ProcessArgs& args) {
for (int i = 0; i < oversample; ++i) {
s = _lpf.next(_saw2.next());
}
- outputs[OUT2_OUTPUT].value = s * 5.0f;
+ outputs[OUT2_OUTPUT].setVoltage(s * 5.0f);
}
#elif ANTIALIASING
@@ -247,8 +247,8 @@ void Test::process(const ProcessArgs& args) {
}
}
- outputs[OUT_OUTPUT].value = out * 5.0f;
- outputs[OUT2_OUTPUT].value = out2 * 5.0f;
+ outputs[OUT_OUTPUT].setVoltage(out * 5.0f);
+ outputs[OUT2_OUTPUT].setVoltage(out2 * 5.0f);
#elif DECIMATORS
const int quality = 12;
@@ -264,9 +264,9 @@ void Test::process(const ProcessArgs& args) {
for (int i = 0; i < OVERSAMPLEN; ++i) {
buf[i] = _saw.next();
}
- outputs[OUT_OUTPUT].value = _cicDecimator.next(buf) * 5.0f;
- // outputs[OUT2_OUTPUT].value = _lpfDecimator.next(buf) * 5.0f;
- outputs[OUT2_OUTPUT].value = _rackDecimator.process(buf) * 5.0f;
+ outputs[OUT_OUTPUT].setVoltage(_cicDecimator.next(buf) * 5.0f);
+ // outputs[OUT2_OUTPUT].setVoltage(_lpfDecimator.next(buf) * 5.0f);
+ outputs[OUT2_OUTPUT].setVoltage(_rackDecimator.process(buf) * 5.0f);
#elif INTERPOLATOR
const int quality = 12;
@@ -285,8 +285,8 @@ void Test::process(const ProcessArgs& args) {
}
_interpolator.next(_decimator.next(_rawSamples), _processedSamples);
}
- outputs[OUT_OUTPUT].value = _processedSamples[_steps] * 5.0f;
- outputs[OUT2_OUTPUT].value = _rawSamples[_steps] * 5.0f;
+ outputs[OUT_OUTPUT].setVoltage(_processedSamples[_steps] * 5.0f);
+ outputs[OUT2_OUTPUT].setVoltage(_rawSamples[_steps] * 5.0f);
++_steps;
#elif FM
@@ -316,11 +316,11 @@ void Test::process(const ProcessArgs& args) {
// linear FM.
float modHz = _ratio * _baseHz;
_carrier.setFrequency(_baseHz + _index * _modulator.next() * modHz); // linear FM requires knowing the modulator's frequency.
- outputs[OUT_OUTPUT].value = _carrier.next() * amplitude;
+ outputs[OUT_OUTPUT].setVoltage(_carrier.next() * amplitude);
// PM for comparison - identical output.
_carrier2.advancePhase();
- outputs[OUT2_OUTPUT].value = _carrier2.nextFromPhasor(_carrier2, Phasor::radiansToPhase(_index * _modulator2.next())) * amplitude;
+ outputs[OUT2_OUTPUT].setVoltage(_carrier2.nextFromPhasor(_carrier2, Phasor::radiansToPhase(_index * _modulator2.next())) * amplitude);
#elif PM
const float amplitude = 5.0f;
@@ -331,49 +331,49 @@ void Test::process(const ProcessArgs& args) {
_modulator.setSampleRate(APP->engine->getSampleRate());
_modulator.setFrequency(modHz);
_carrier.advancePhase();
- outputs[OUT_OUTPUT].value = _carrier.nextFromPhasor(_carrier, Phasor::radiansToPhase(index3() * _modulator.next())) * amplitude;
+ outputs[OUT_OUTPUT].setVoltage(_carrier.nextFromPhasor(_carrier, Phasor::radiansToPhase(index3() * _modulator.next())) * amplitude);
#elif FEEDBACK_PM
_carrier.setSampleRate(APP->engine->getSampleRate());
_carrier.setFrequency(oscillatorPitch());
- float feedback = params[PARAM2_PARAM].value;
- if (inputs[CV2_INPUT].active) {
- feedback *= clamp(inputs[CV2_INPUT].value, 0.0f, 10.0f) / 10.0f;
+ float feedback = params[PARAM2_PARAM].getValue();
+ if (inputs[CV2_INPUT].isConnected()) {
+ feedback *= clamp(inputs[CV2_INPUT].getVoltage(), 0.0f, 10.0f) / 10.0f;
}
_carrier.advancePhase();
- outputs[OUT_OUTPUT].value = _feedbackSample = _carrier.nextFromPhasor(_carrier, Phasor::radiansToPhase(feedback * _feedbackSample)) * 5.0f;
+ outputs[OUT_OUTPUT].setVoltage(_feedbackSample = _carrier.nextFromPhasor(_carrier, Phasor::radiansToPhase(feedback * _feedbackSample)) * 5.0f);
#elif EG
_envelope.setSampleRate(APP->engine->getSampleRate());
- _envelope.setAttack(params[PARAM1_PARAM].value);
- _envelope.setDecay(params[PARAM2_PARAM].value);
- _envelope.setSustain(params[PARAM3_PARAM].value);
- _envelope.setRelease(params[PARAM2_PARAM].value);
- _envelope.setGate(inputs[CV1_INPUT].value > 0.1f);
- outputs[OUT_OUTPUT].value = _envelope.next() * 10.0f;
+ _envelope.setAttack(params[PARAM1_PARAM].getValue());
+ _envelope.setDecay(params[PARAM2_PARAM].getValue());
+ _envelope.setSustain(params[PARAM3_PARAM].getValue());
+ _envelope.setRelease(params[PARAM2_PARAM].getValue());
+ _envelope.setGate(inputs[CV1_INPUT].getVoltage() > 0.1f);
+ outputs[OUT_OUTPUT].setVoltage(_envelope.next() * 10.0f);
#elif TABLES
_sine.setSampleRate(APP->engine->getSampleRate());
_sine.setFrequency(oscillatorPitch());
- outputs[OUT_OUTPUT].value = _sine.next() * 5.0f;
+ outputs[OUT_OUTPUT].setVoltage(_sine.next() * 5.0f);
_table.setSampleRate(APP->engine->getSampleRate());
_table.setFrequency(oscillatorPitch());
- outputs[OUT2_OUTPUT].value = _table.next() * 5.0f;
+ outputs[OUT2_OUTPUT].setVoltage(_table.next() * 5.0f);
#elif SLEW
- float ms = params[PARAM1_PARAM].value;
- if (inputs[CV1_INPUT].active) {
- ms *= clamp(inputs[CV2_INPUT].value, 0.0f, 10.0f) / 10.0f;
+ float ms = params[PARAM1_PARAM].getValue();
+ if (inputs[CV1_INPUT].isConnected()) {
+ ms *= clamp(inputs[CV2_INPUT].getVoltage(), 0.0f, 10.0f) / 10.0f;
}
ms = powf(ms, 2.0f);
ms *= 10000.0f;
_slew.setParams(APP->engine->getSampleRate(), ms);
- outputs[OUT_OUTPUT].value = _slew.next(inputs[IN_INPUT].value);
+ outputs[OUT_OUTPUT].setVoltage(_slew.next(inputs[IN_INPUT].getVoltage()));
- float shape = params[PARAM2_PARAM].value;
- if (inputs[CV2_INPUT].active) {
- shape *= clamp(inputs[CV2_INPUT].value / 5.0f, -1.0f, 1.0f);
+ float shape = params[PARAM2_PARAM].getValue();
+ if (inputs[CV2_INPUT].isConnected()) {
+ shape *= clamp(inputs[CV2_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
}
if (shape < 0.5) {
shape /= 0.5;
@@ -386,86 +386,86 @@ void Test::process(const ProcessArgs& args) {
shape += 1.0f;
}
_slew2.setParams(APP->engine->getSampleRate(), ms, shape);
- outputs[OUT2_OUTPUT].value = _slew2.next(inputs[IN_INPUT].value);
+ outputs[OUT2_OUTPUT].setVoltage(_slew2.next(inputs[IN_INPUT].getVoltage()));
#elif RMS
- float sensitivity = params[PARAM2_PARAM].value;
- if (inputs[CV2_INPUT].active) {
- sensitivity *= clamp(inputs[CV2_INPUT].value, 0.0f, 10.0f) / 10.0f;
+ float sensitivity = params[PARAM2_PARAM].getValue();
+ if (inputs[CV2_INPUT].isConnected()) {
+ sensitivity *= clamp(inputs[CV2_INPUT].getVoltage(), 0.0f, 10.0f) / 10.0f;
}
_rms.setSampleRate(APP->engine->getSampleRate());
_rms.setSensitivity(sensitivity);
- outputs[OUT_OUTPUT].value = _rms.next(inputs[IN_INPUT].value);
+ outputs[OUT_OUTPUT].setVoltage(_rms.next(inputs[IN_INPUT].getVoltage()));
_pef.setSensitivity(sensitivity);
- outputs[OUT2_OUTPUT].value = _pef.next(inputs[IN_INPUT].value);
+ outputs[OUT2_OUTPUT].setVoltage(_pef.next(inputs[IN_INPUT].getVoltage()));
#elif RAVG
- if (_reset.process(inputs[CV1_INPUT].value)) {
+ if (_reset.process(inputs[CV1_INPUT].getVoltage())) {
_average.reset();
}
- outputs[OUT_OUTPUT].value = _average.next(inputs[IN_INPUT].value);
+ outputs[OUT_OUTPUT].setVoltage(_average.next(inputs[IN_INPUT].getVoltage()));
#elif SATURATOR
- float in = inputs[IN_INPUT].value;
- outputs[OUT_OUTPUT].value = _saturator.next(in);
- outputs[OUT2_OUTPUT].value = clamp(in, -Saturator::limit, Saturator::limit);
+ float in = inputs[IN_INPUT].getVoltage();
+ outputs[OUT_OUTPUT].setVoltage(_saturator.next(in));
+ outputs[OUT2_OUTPUT].setVoltage(clamp(in, -Saturator::limit, Saturator::limit));
#elif BROWNIAN
const float maxDiv = 1000.0f;
- float change = clamp(1.0f - params[PARAM1_PARAM].value, 0.01f, 1.0f);
- float smooth = clamp(params[PARAM2_PARAM].value, 0.01f, 1.0f);
+ float change = clamp(1.0f - params[PARAM1_PARAM].getValue(), 0.01f, 1.0f);
+ float smooth = clamp(params[PARAM2_PARAM].getValue(), 0.01f, 1.0f);
smooth *= smooth;
_filter1.setParams(APP->engine->getSampleRate(), smooth * APP->engine->getSampleRate() * 0.49f);
_filter2.setParams(APP->engine->getSampleRate(), smooth * APP->engine->getSampleRate() * 0.49f);
_last1 = _last1 + _noise1.next() / (change * maxDiv);
- outputs[OUT_OUTPUT].value = _filter1.next(_last1);
+ outputs[OUT_OUTPUT].setVoltage(_filter1.next(_last1));
if (_last1 > 5.0f || _last1 < -5.0f) {
_last1 = 0.0f;
}
_last2 = _last2 + _noise1.next() / (change * maxDiv);
- outputs[OUT2_OUTPUT].value = _filter2.next(_last2);
+ outputs[OUT2_OUTPUT].setVoltage(_filter2.next(_last2));
if (_last2 > 5.0f || _last2 < -5.0f) {
_last2 = 0.0f;
}
// // "leaky integrator"
- // float alpha = params[PARAM1_PARAM].value;
+ // float alpha = params[PARAM1_PARAM].getValue();
// alpha = clamp(1.0f - alpha*alpha, 0.00001f, 1.0f);
// float sample = 5.0f * _noise1.next();
// _last1 = alpha*_last1 + (1.0f - alpha)*sample;
- // outputs[OUT_OUTPUT].value = _last1;
+ // outputs[OUT_OUTPUT].setVoltage(_last1);
#elif RANDOMWALK
- float change = params[PARAM1_PARAM].value;
+ float change = params[PARAM1_PARAM].getValue();
change *= change;
change *= change;
_walk1.setParams(APP->engine->getSampleRate(), change);
_walk2.setParams(APP->engine->getSampleRate(), change);
- outputs[OUT_OUTPUT].value = _walk1.next();
- outputs[OUT2_OUTPUT].value = _walk2.next();
+ outputs[OUT_OUTPUT].setVoltage(_walk1.next());
+ outputs[OUT2_OUTPUT].setVoltage(_walk2.next());
#endif
}
float Test::oscillatorPitch(float max) {
- if (inputs[CV1_INPUT].active) {
- return cvToFrequency(inputs[CV1_INPUT].value);
+ if (inputs[CV1_INPUT].isConnected()) {
+ return cvToFrequency(inputs[CV1_INPUT].getVoltage());
}
- return max * powf(params[PARAM1_PARAM].value, 2.0);
+ return max * powf(params[PARAM1_PARAM].getValue(), 2.0);
}
float Test::oscillatorPitch2(float max) {
- if (inputs[CV2_INPUT].active) {
- return cvToFrequency(inputs[CV2_INPUT].value);
+ if (inputs[CV2_INPUT].isConnected()) {
+ return cvToFrequency(inputs[CV2_INPUT].getVoltage());
}
- return max * powf(params[PARAM2_PARAM].value, 2.0);
+ return max * powf(params[PARAM2_PARAM].getValue(), 2.0);
}
float Test::ratio2() {
- float ratio = (params[PARAM2_PARAM].value * 2.0f) - 1.0f;
- if (inputs[CV2_INPUT].active) {
- ratio *= clamp(inputs[CV2_INPUT].value / 5.0f, -1.0f, 1.0f);
+ float ratio = (params[PARAM2_PARAM].getValue() * 2.0f) - 1.0f;
+ if (inputs[CV2_INPUT].isConnected()) {
+ ratio *= clamp(inputs[CV2_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
}
if (ratio < 0.0f) {
return 1.0f + ratio;
@@ -474,9 +474,9 @@ float Test::ratio2() {
}
float Test::index3() {
- float index = params[PARAM3_PARAM].value;
- if (inputs[CV3_INPUT].active) {
- index *= clamp(inputs[CV3_INPUT].value, 0.0f, 10.0f) / 10.0f;
+ float index = params[PARAM3_PARAM].getValue();
+ if (inputs[CV3_INPUT].isConnected()) {
+ index *= clamp(inputs[CV3_INPUT].getVoltage(), 0.0f, 10.0f) / 10.0f;
}
return index * 10.0f;
}
diff --git a/src/Test2.cpp b/src/Test2.cpp
@@ -9,23 +9,23 @@ void Test2::onReset() {
}
void Test2::process(const ProcessArgs& args) {
- if (!outputs[OUT_OUTPUT].active) {
+ if (!outputs[OUT_OUTPUT].isConnected()) {
return;
}
#ifdef COMPLEX_BIQUAD
_complexBiquad.setComplexParams(
- params[PARAM1B_PARAM].value,
- params[PARAM2A_PARAM].value,
- params[PARAM2B_PARAM].value * M_PI,
- std::min(params[PARAM3A_PARAM].value, 0.9f),
- params[PARAM3B_PARAM].value * M_PI
+ params[PARAM1B_PARAM].getValue(),
+ params[PARAM2A_PARAM].getValue(),
+ params[PARAM2B_PARAM].getValue() * M_PI,
+ std::min(params[PARAM3A_PARAM].getValue(), 0.9f),
+ params[PARAM3B_PARAM].getValue() * M_PI
);
float in = 0.0f;
- if (inputs[IN_INPUT].active) {
- in = inputs[IN_INPUT].value;
+ if (inputs[IN_INPUT].isConnected()) {
+ in = inputs[IN_INPUT].getVoltage();
}
- outputs[OUT_OUTPUT].value = _complexBiquad.next(in);
+ outputs[OUT_OUTPUT].setVoltage(_complexBiquad.next(in));
#elif MULTIPOLE
++_steps;
@@ -33,11 +33,11 @@ void Test2::process(const ProcessArgs& args) {
_steps = 0;
_filter.setParams(
- params[PARAM2A_PARAM].value <= 0.5f ? MultipoleFilter::LP_TYPE : MultipoleFilter::HP_TYPE,
- 2 * clamp((int)(params[PARAM1B_PARAM].value * (MultipoleFilter::maxPoles / 2)), 1, MultipoleFilter::maxPoles / 2),
+ params[PARAM2A_PARAM].getValue() <= 0.5f ? MultipoleFilter::LP_TYPE : MultipoleFilter::HP_TYPE,
+ 2 * clamp((int)(params[PARAM1B_PARAM].getValue() * (MultipoleFilter::maxPoles / 2)), 1, MultipoleFilter::maxPoles / 2),
APP->engine->getSampleRate(),
- params[PARAM1A_PARAM].value * APP->engine->getSampleRate() / 2.0f,
- params[PARAM2B_PARAM].value * MultipoleFilter::maxRipple
+ params[PARAM1A_PARAM].getValue() * APP->engine->getSampleRate() / 2.0f,
+ params[PARAM2B_PARAM].getValue() * MultipoleFilter::maxRipple
);
// _filter.setParams(
// MultipoleFilter::HP_TYPE,
@@ -48,23 +48,23 @@ void Test2::process(const ProcessArgs& args) {
// );
}
float in = 0.0f;
- if (inputs[IN_INPUT].active) {
- in = inputs[IN_INPUT].value;
+ if (inputs[IN_INPUT].isConnected()) {
+ in = inputs[IN_INPUT].getVoltage();
}
- outputs[OUT_OUTPUT].value = _filter.next(in);
+ outputs[OUT_OUTPUT].setVoltage(_filter.next(in));
#elif ADSR_ENVELOPE
- if (outputs[OUT_OUTPUT].active) {
+ if (outputs[OUT_OUTPUT].isConnected()) {
_adsr.setSampleRate(APP->engine->getSampleRate());
- if (inputs[IN_INPUT].active) {
- _trigger.process(inputs[IN_INPUT].value);
+ if (inputs[IN_INPUT].isConnected()) {
+ _trigger.process(inputs[IN_INPUT].getVoltage());
}
_adsr.setGate(_trigger.isHigh());
- _adsr.setAttack(powf(params[PARAM1A_PARAM].value, 2.0f) * 10.0f);
- _adsr.setDecay(powf(params[PARAM1B_PARAM].value, 2.0f) * 10.0f);
- _adsr.setSustain(params[PARAM2A_PARAM].value);
- _adsr.setRelease(powf(params[PARAM2B_PARAM].value, 2.0f) * 10.0f);
- float attackShape = params[PARAM3A_PARAM].value;
+ _adsr.setAttack(powf(params[PARAM1A_PARAM].getValue(), 2.0f) * 10.0f);
+ _adsr.setDecay(powf(params[PARAM1B_PARAM].getValue(), 2.0f) * 10.0f);
+ _adsr.setSustain(params[PARAM2A_PARAM].getValue());
+ _adsr.setRelease(powf(params[PARAM2B_PARAM].getValue(), 2.0f) * 10.0f);
+ float attackShape = params[PARAM3A_PARAM].getValue();
if (attackShape < 0.5f) {
attackShape += 0.5f;
}
@@ -73,7 +73,7 @@ void Test2::process(const ProcessArgs& args) {
attackShape *= 2.0f;
attackShape += 1.0f;
}
- float decayShape = params[PARAM3B_PARAM].value;
+ float decayShape = params[PARAM3B_PARAM].getValue();
if (decayShape < 0.5f) {
decayShape += 0.5f;
}
@@ -83,24 +83,24 @@ void Test2::process(const ProcessArgs& args) {
decayShape += 1.0f;
}
_adsr.setShapes(attackShape, decayShape, decayShape);
- outputs[OUT_OUTPUT].value = _adsr.next() * 10.0f;
+ outputs[OUT_OUTPUT].setVoltage(_adsr.next() * 10.0f);
}
#elif LIMITER
- float shape = params[PARAM1A_PARAM].value * 5.0f;
- float knee = params[PARAM2A_PARAM].value * 10.0f;
- float limit = params[PARAM2B_PARAM].value * 15.0f;
- float scale = params[PARAM1B_PARAM].value * 2.0f + 1.0f;
+ float shape = params[PARAM1A_PARAM].getValue() * 5.0f;
+ float knee = params[PARAM2A_PARAM].getValue() * 10.0f;
+ float limit = params[PARAM2B_PARAM].getValue() * 15.0f;
+ float scale = params[PARAM1B_PARAM].getValue() * 2.0f + 1.0f;
_limiter.setParams(shape, knee, limit, scale);
- outputs[OUT_OUTPUT].value = _limiter.next(inputs[IN_INPUT].value);
+ outputs[OUT_OUTPUT].setVoltage(_limiter.next(inputs[IN_INPUT].getVoltage()));
#endif
}
// float Test2::oscillatorPitch1A() {
-// if (inputs[CV1A_INPUT].active) {
-// return cvToFrequency(inputs[CV1A_INPUT].value);
+// if (inputs[CV1A_INPUT].isConnected()) {
+// return cvToFrequency(inputs[CV1A_INPUT].getVoltage());
// }
-// return 10000.0 * powf(params[PARAM1_PARAM].value, 2.0);
+// return 10000.0 * powf(params[PARAM1_PARAM].getValue(), 2.0);
// }
diff --git a/src/UMix.cpp b/src/UMix.cpp
@@ -24,43 +24,43 @@ void UMix::dataFromJson(json_t* root) {
}
void UMix::process(const ProcessArgs& args) {
- if (!outputs[OUT_OUTPUT].active) {
+ if (!outputs[OUT_OUTPUT].isConnected()) {
return;
}
if (_sum) {
float out = 0.0f;
for (int i = 0; i < 8; ++i) {
- out += inputs[IN1_INPUT + i].value;
+ out += inputs[IN1_INPUT + i].getVoltage();
}
- out *= params[LEVEL_PARAM].value;
+ out *= params[LEVEL_PARAM].getValue();
if (_cvMode) {
- outputs[OUT_OUTPUT].value = clamp(out, -12.0f, 12.0f);
+ outputs[OUT_OUTPUT].setVoltage(clamp(out, -12.0f, 12.0f));
}
else {
- outputs[OUT_OUTPUT].value = _saturator.next(out);
+ outputs[OUT_OUTPUT].setVoltage(_saturator.next(out));
}
}
else {
float out = 0.0f;
int active = 0;
for (int i = 0; i < 8; ++i) {
- if (inputs[IN1_INPUT + i].active) {
- out += inputs[IN1_INPUT + i].value;
+ if (inputs[IN1_INPUT + i].isConnected()) {
+ out += inputs[IN1_INPUT + i].getVoltage();
++active;
}
}
if (active > 0) {
out /= (float)active;
- out *= params[LEVEL_PARAM].value;
+ out *= params[LEVEL_PARAM].getValue();
if (_cvMode) {
- outputs[OUT_OUTPUT].value = clamp(out, -12.0f, 12.0f);
+ outputs[OUT_OUTPUT].setVoltage(clamp(out, -12.0f, 12.0f));
}
else {
- outputs[OUT_OUTPUT].value = _saturator.next(out);
+ outputs[OUT_OUTPUT].setVoltage(_saturator.next(out));
}
}
else {
- outputs[OUT_OUTPUT].value = 0.0f;
+ outputs[OUT_OUTPUT].setVoltage(0.0f);
}
}
}
diff --git a/src/VCA.cpp b/src/VCA.cpp
@@ -8,7 +8,7 @@ void VCA::onSampleRateChange() {
}
void VCA::process(const ProcessArgs& args) {
- bool linear = params[LINEAR_PARAM].value > 0.5f;
+ bool linear = params[LINEAR_PARAM].getValue() > 0.5f;
lights[LINEAR_LIGHT].value = linear;
channelStep(inputs[IN1_INPUT], outputs[OUT1_OUTPUT], params[LEVEL1_PARAM], inputs[CV1_INPUT], _amplifier1, _levelSL1, linear);
channelStep(inputs[IN2_INPUT], outputs[OUT2_OUTPUT], params[LEVEL2_PARAM], inputs[CV2_INPUT], _amplifier2, _levelSL2, linear);
diff --git a/src/VCAmp.cpp b/src/VCAmp.cpp
@@ -12,15 +12,15 @@ void VCAmp::onSampleRateChange() {
}
void VCAmp::process(const ProcessArgs& args) {
- if (inputs[IN_INPUT].active) {
- float level = params[LEVEL_PARAM].value;
- if (inputs[CV_INPUT].active) {
- level *= clamp(inputs[CV_INPUT].value, 0.0f, 10.0f) / 10.0f;
+ if (inputs[IN_INPUT].isConnected()) {
+ float level = params[LEVEL_PARAM].getValue();
+ if (inputs[CV_INPUT].isConnected()) {
+ level *= clamp(inputs[CV_INPUT].getVoltage(), 0.0f, 10.0f) / 10.0f;
}
level *= maxDecibels - minDecibels;
level += minDecibels;
_amplifier.setLevel(_levelSL.next(level));
- outputs[OUT_OUTPUT].value = _saturator.next(_amplifier.next(inputs[IN_INPUT].value));
+ outputs[OUT_OUTPUT].setVoltage(_saturator.next(_amplifier.next(inputs[IN_INPUT].getVoltage())));
_rmsLevel = _rms.next(outputs[OUT_OUTPUT].value / 5.0f);
}
else {
diff --git a/src/VCM.cpp b/src/VCM.cpp
@@ -2,22 +2,22 @@
#include "VCM.hpp"
void VCM::process(const ProcessArgs& args) {
- bool linear = params[LINEAR_PARAM].value > 0.5f;
+ bool linear = params[LINEAR_PARAM].getValue() > 0.5f;
lights[LINEAR_LIGHT].value = linear;
- if (outputs[MIX_OUTPUT].active) {
+ if (outputs[MIX_OUTPUT].isConnected()) {
float out = channelStep(inputs[IN1_INPUT], params[LEVEL1_PARAM], inputs[CV1_INPUT], _amplifier1, linear);
out += channelStep(inputs[IN2_INPUT], params[LEVEL2_PARAM], inputs[CV2_INPUT], _amplifier2, linear);
out += channelStep(inputs[IN3_INPUT], params[LEVEL3_PARAM], inputs[CV3_INPUT], _amplifier3, linear);
out += channelStep(inputs[IN4_INPUT], params[LEVEL4_PARAM], inputs[CV4_INPUT], _amplifier4, linear);
- float level = params[MIX_PARAM].value;
- if (inputs[MIX_CV_INPUT].active) {
- level *= clamp(inputs[MIX_CV_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float level = params[MIX_PARAM].getValue();
+ if (inputs[MIX_CV_INPUT].isConnected()) {
+ level *= clamp(inputs[MIX_CV_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
out *= level;
if (!_disableOutputLimit) {
out = clamp(out, -12.0f, 12.0f);
}
- outputs[MIX_OUTPUT].value = level * out;
+ outputs[MIX_OUTPUT].setVoltage(level * out);
}
}
diff --git a/src/VCO.cpp b/src/VCO.cpp
@@ -13,14 +13,14 @@ void VCO::onSampleRateChange() {
}
void VCO::process(const ProcessArgs& args) {
- lights[SLOW_LIGHT].value = _slowMode = params[SLOW_PARAM].value > 0.5f;
- _fmLinearMode = params[FM_TYPE_PARAM].value < 0.5f;
+ lights[SLOW_LIGHT].value = _slowMode = params[SLOW_PARAM].getValue() > 0.5f;
+ _fmLinearMode = params[FM_TYPE_PARAM].getValue() < 0.5f;
if (!(
- outputs[SQUARE_OUTPUT].active ||
- outputs[SAW_OUTPUT].active ||
- outputs[TRIANGLE_OUTPUT].active ||
- outputs[SINE_OUTPUT].active
+ outputs[SQUARE_OUTPUT].isConnected() ||
+ outputs[SAW_OUTPUT].isConnected() ||
+ outputs[TRIANGLE_OUTPUT].isConnected() ||
+ outputs[SINE_OUTPUT].isConnected()
)) {
return;
}
@@ -29,36 +29,36 @@ void VCO::process(const ProcessArgs& args) {
if (_modulationStep >= modulationSteps) {
_modulationStep = 0;
- _baseVOct = params[FREQUENCY_PARAM].value;
- _baseVOct += params[FINE_PARAM].value / 12.0f;
- if (inputs[PITCH_INPUT].active) {
- _baseVOct += clamp(inputs[PITCH_INPUT].value, -5.0f, 5.0f);
+ _baseVOct = params[FREQUENCY_PARAM].getValue();
+ _baseVOct += params[FINE_PARAM].getValue() / 12.0f;
+ if (inputs[PITCH_INPUT].isConnected()) {
+ _baseVOct += clamp(inputs[PITCH_INPUT].getVoltage(), -5.0f, 5.0f);
}
if (_slowMode) {
_baseVOct -= 7.0f;
}
_baseHz = cvToFrequency(_baseVOct);
- float pw = params[PW_PARAM].value;
- if (inputs[PW_INPUT].active) {
- pw *= clamp(inputs[PW_INPUT].value / 5.0f, -1.0f, 1.0f);
+ float pw = params[PW_PARAM].getValue();
+ if (inputs[PW_INPUT].isConnected()) {
+ pw *= clamp(inputs[PW_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
}
pw *= 1.0f - 2.0f * _square.minPulseWidth;
pw *= 0.5f;
pw += 0.5f;
_square.setPulseWidth(_squarePulseWidthSL.next(pw));
- _fmDepth = params[FM_PARAM].value;
+ _fmDepth = params[FM_PARAM].getValue();
}
- if (_syncTrigger.next(inputs[SYNC_INPUT].value)) {
+ if (_syncTrigger.next(inputs[SYNC_INPUT].getVoltage())) {
_phasor.resetPhase();
}
float frequency = _baseHz;
Phasor::phase_delta_t phaseOffset = 0;
- if (inputs[FM_INPUT].active && _fmDepth > 0.01f) {
- float fm = inputs[FM_INPUT].value * _fmDepth;
+ if (inputs[FM_INPUT].isConnected() && _fmDepth > 0.01f) {
+ float fm = inputs[FM_INPUT].getVoltage() * _fmDepth;
if (_fmLinearMode) {
phaseOffset = Phasor::radiansToPhase(2.0f * fm);
}
@@ -91,23 +91,23 @@ void VCO::process(const ProcessArgs& args) {
if (oMix > 0.0f) {
for (int i = 0; i < oversample; ++i) {
_phasor.advancePhase();
- if (outputs[SQUARE_OUTPUT].active) {
+ if (outputs[SQUARE_OUTPUT].isConnected()) {
_squareBuffer[i] = _square.nextFromPhasor(_phasor, phaseOffset);
}
- if (outputs[SAW_OUTPUT].active) {
+ if (outputs[SAW_OUTPUT].isConnected()) {
_sawBuffer[i] = _saw.nextFromPhasor(_phasor, phaseOffset);
}
- if (outputs[TRIANGLE_OUTPUT].active) {
+ if (outputs[TRIANGLE_OUTPUT].isConnected()) {
_triangleBuffer[i] = _triangle.nextFromPhasor(_phasor, phaseOffset);
}
}
- if (outputs[SQUARE_OUTPUT].active) {
+ if (outputs[SQUARE_OUTPUT].isConnected()) {
squareOut += oMix * amplitude * _squareDecimator.next(_squareBuffer);
}
- if (outputs[SAW_OUTPUT].active) {
+ if (outputs[SAW_OUTPUT].isConnected()) {
sawOut += oMix * amplitude * _sawDecimator.next(_sawBuffer);
}
- if (outputs[TRIANGLE_OUTPUT].active) {
+ if (outputs[TRIANGLE_OUTPUT].isConnected()) {
triangleOut += oMix * amplitude * _triangleDecimator.next(_triangleBuffer);
}
}
@@ -115,21 +115,21 @@ void VCO::process(const ProcessArgs& args) {
_phasor.advancePhase(oversample);
}
if (mix > 0.0f) {
- if (outputs[SQUARE_OUTPUT].active) {
+ if (outputs[SQUARE_OUTPUT].isConnected()) {
squareOut += mix * amplitude * _square.nextFromPhasor(_phasor, phaseOffset);
}
- if (outputs[SAW_OUTPUT].active) {
+ if (outputs[SAW_OUTPUT].isConnected()) {
sawOut += mix * amplitude * _saw.nextFromPhasor(_phasor, phaseOffset);
}
- if (outputs[TRIANGLE_OUTPUT].active) {
+ if (outputs[TRIANGLE_OUTPUT].isConnected()) {
triangleOut += mix * amplitude * _triangle.nextFromPhasor(_phasor, phaseOffset);
}
}
- outputs[SQUARE_OUTPUT].value = squareOut;
- outputs[SAW_OUTPUT].value = sawOut;
- outputs[TRIANGLE_OUTPUT].value = triangleOut;
- outputs[SINE_OUTPUT].value = outputs[SINE_OUTPUT].active ? (amplitude * _sine.nextFromPhasor(_phasor, phaseOffset)) : 0.0f;
+ outputs[SQUARE_OUTPUT].setVoltage(squareOut);
+ outputs[SAW_OUTPUT].setVoltage(sawOut);
+ outputs[TRIANGLE_OUTPUT].setVoltage(triangleOut);
+ outputs[SINE_OUTPUT].setVoltage(outputs[SINE_OUTPUT].isConnected() ? (amplitude * _sine.nextFromPhasor(_phasor, phaseOffset)) : 0.0f);
}
void VCO::setSampleRate(float sampleRate) {
diff --git a/src/VU.cpp b/src/VU.cpp
@@ -9,19 +9,19 @@ void VU::onSampleRateChange() {
void VU::process(const ProcessArgs& args) {
float left = 0.0f;
float right = 0.0f;
- if (inputs[L_INPUT].active) {
- left = inputs[L_INPUT].value;
+ if (inputs[L_INPUT].isConnected()) {
+ left = inputs[L_INPUT].getVoltage();
}
- if (inputs[R_INPUT].active) {
- right = inputs[R_INPUT].value;
+ if (inputs[R_INPUT].isConnected()) {
+ right = inputs[R_INPUT].getVoltage();
}
else {
right = left;
}
_lLevel = _lRms.next(left) / 5.0f;
_rLevel = _rRms.next(right) / 5.0f;
- outputs[L_OUTPUT].value = left;
- outputs[R_OUTPUT].value = right;
+ outputs[L_OUTPUT].setVoltage(left);
+ outputs[R_OUTPUT].setVoltage(right);
}
struct VUDisplay : OpaqueWidget {
diff --git a/src/Walk.cpp b/src/Walk.cpp
@@ -16,33 +16,33 @@ void Walk::process(const ProcessArgs& args) {
if (_modulationStep >= modulationSteps) {
_modulationStep = 0;
- float rate = params[RATE_PARAM].value;
- if (inputs[RATE_INPUT].active) {
- rate *= clamp(inputs[RATE_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float rate = params[RATE_PARAM].getValue();
+ if (inputs[RATE_INPUT].isConnected()) {
+ rate *= clamp(inputs[RATE_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
rate = 0.2f * powf(rate, 5.0f);
_walk.setParams(APP->engine->getSampleRate(), rate);
- _offset = params[OFFSET_PARAM].value;
- if (inputs[OFFSET_INPUT].active) {
- _offset *= clamp(inputs[OFFSET_INPUT].value / 5.0f, -1.0f, 1.0f);
+ _offset = params[OFFSET_PARAM].getValue();
+ if (inputs[OFFSET_INPUT].isConnected()) {
+ _offset *= clamp(inputs[OFFSET_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
}
_offset *= 5.0f;
- _scale = params[SCALE_PARAM].value;
- if (inputs[SCALE_INPUT].active) {
- _scale *= clamp(inputs[SCALE_INPUT].value / 10.0f, 0.0f, 1.0f);
+ _scale = params[SCALE_PARAM].getValue();
+ if (inputs[SCALE_INPUT].isConnected()) {
+ _scale *= clamp(inputs[SCALE_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
}
- if (_jumpTrigger.process(inputs[JUMP_INPUT].value)) {
+ if (_jumpTrigger.process(inputs[JUMP_INPUT].getVoltage())) {
_walk.jump();
}
float out = _slew.next(_walk.next());
out *= _scale;
out += _offset;
- outputs[OUT_OUTPUT].value = out;
+ outputs[OUT_OUTPUT].setVoltage(out);
}
struct WalkWidget : ModuleWidget {
diff --git a/src/Walk2.cpp b/src/Walk2.cpp
@@ -48,42 +48,42 @@ void Walk2::process(const ProcessArgs& args) {
_modulationStep = 0;
float sampleRate = APP->engine->getSampleRate();
- float rateX = params[RATE_X_PARAM].value;
- if (inputs[RATE_X_INPUT].active) {
- rateX *= clamp(inputs[RATE_X_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float rateX = params[RATE_X_PARAM].getValue();
+ if (inputs[RATE_X_INPUT].isConnected()) {
+ rateX *= clamp(inputs[RATE_X_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
rateX = scaleRate(rateX);
_walkX.setParams(sampleRate, rateX);
_slewX.setParams(sampleRate, std::max((1.0f - rateX) * 100.0f, 0.0f), 10.0f);
- _offsetX = params[OFFSET_X_PARAM].value;
- if (inputs[OFFSET_X_INPUT].active) {
- _offsetX *= clamp(inputs[OFFSET_X_INPUT].value / 5.0f, -1.0f, 1.0f);
+ _offsetX = params[OFFSET_X_PARAM].getValue();
+ if (inputs[OFFSET_X_INPUT].isConnected()) {
+ _offsetX *= clamp(inputs[OFFSET_X_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
}
_offsetX *= 5.0f;
- _scaleX = params[SCALE_X_PARAM].value;
- if (inputs[SCALE_X_INPUT].active) {
- _scaleX *= clamp(inputs[SCALE_X_INPUT].value / 10.0f, 0.0f, 1.0f);
+ _scaleX = params[SCALE_X_PARAM].getValue();
+ if (inputs[SCALE_X_INPUT].isConnected()) {
+ _scaleX *= clamp(inputs[SCALE_X_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
- float rateY = params[RATE_Y_PARAM].value;
- if (inputs[RATE_Y_INPUT].active) {
- rateY *= clamp(inputs[RATE_Y_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float rateY = params[RATE_Y_PARAM].getValue();
+ if (inputs[RATE_Y_INPUT].isConnected()) {
+ rateY *= clamp(inputs[RATE_Y_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
rateY = scaleRate(rateY);
_walkY.setParams(sampleRate, rateY);
_slewY.setParams(sampleRate, std::max((1.0f - rateY) * 100.0f, 0.0f), 10.0f);
- _offsetY = params[OFFSET_Y_PARAM].value;
- if (inputs[OFFSET_Y_INPUT].active) {
- _offsetY *= clamp(inputs[OFFSET_Y_INPUT].value / 5.0f, -1.0f, 1.0f);
+ _offsetY = params[OFFSET_Y_PARAM].getValue();
+ if (inputs[OFFSET_Y_INPUT].isConnected()) {
+ _offsetY *= clamp(inputs[OFFSET_Y_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
}
_offsetY *= 5.0f;
- _scaleY = params[SCALE_Y_PARAM].value;
- if (inputs[SCALE_Y_INPUT].active) {
- _scaleY *= clamp(inputs[SCALE_Y_INPUT].value / 10.0f, 0.0f, 1.0f);
+ _scaleY = params[SCALE_Y_PARAM].getValue();
+ if (inputs[SCALE_Y_INPUT].isConnected()) {
+ _scaleY *= clamp(inputs[SCALE_Y_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
}
@@ -94,7 +94,7 @@ void Walk2::process(const ProcessArgs& args) {
_walkY.tell(jumpTo->y);
delete jumpTo;
}
- else if (_jumpTrigger.process(inputs[JUMP_INPUT].value)) {
+ else if (_jumpTrigger.process(inputs[JUMP_INPUT].getVoltage())) {
_walkX.jump();
_walkY.jump();
}
@@ -102,14 +102,14 @@ void Walk2::process(const ProcessArgs& args) {
float outX = _slewX.next(_walkX.next());
outX *= _scaleX;
outX += _offsetX;
- outputs[OUT_X_OUTPUT].value = outX;
+ outputs[OUT_X_OUTPUT].setVoltage(outX);
float outY = _slewY.next(_walkY.next());
outY *= _scaleY;
outY += _offsetY;
- outputs[OUT_Y_OUTPUT].value = outY;
+ outputs[OUT_Y_OUTPUT].setVoltage(outY);
- outputs[DISTANCE_OUTPUT].value = sqrtf(outX*outX + outY*outY) * 0.707107f; // scaling constant is 10 / squrt(200)
+ outputs[DISTANCE_OUTPUT].setVoltage(sqrtf(outX*outX + outY*outY) * 0.707107f); // scaling constant is 10 / squrt(200)
if (_historyStep == 0) {
_outsX.push(outX);
diff --git a/src/XCO.cpp b/src/XCO.cpp
@@ -13,15 +13,15 @@ void XCO::onSampleRateChange() {
}
void XCO::process(const ProcessArgs& args) {
- lights[SLOW_LIGHT].value = _slowMode = params[SLOW_PARAM].value > 0.5f;
- _fmLinearMode = params[FM_TYPE_PARAM].value < 0.5f;
+ lights[SLOW_LIGHT].value = _slowMode = params[SLOW_PARAM].getValue() > 0.5f;
+ _fmLinearMode = params[FM_TYPE_PARAM].getValue() < 0.5f;
if (!(
- outputs[MIX_OUTPUT].active ||
- outputs[SQUARE_OUTPUT].active ||
- outputs[SAW_OUTPUT].active ||
- outputs[TRIANGLE_OUTPUT].active ||
- outputs[SINE_OUTPUT].active
+ outputs[MIX_OUTPUT].isConnected() ||
+ outputs[SQUARE_OUTPUT].isConnected() ||
+ outputs[SAW_OUTPUT].isConnected() ||
+ outputs[TRIANGLE_OUTPUT].isConnected() ||
+ outputs[SINE_OUTPUT].isConnected()
)) {
return;
}
@@ -30,47 +30,47 @@ void XCO::process(const ProcessArgs& args) {
if (_modulationStep >= modulationSteps) {
_modulationStep = 0;
- _baseVOct = params[FREQUENCY_PARAM].value;
- _baseVOct += params[FINE_PARAM].value / 12.0f;;
- if (inputs[PITCH_INPUT].active) {
- _baseVOct += clamp(inputs[PITCH_INPUT].value, -5.0f, 5.0f);
+ _baseVOct = params[FREQUENCY_PARAM].getValue();
+ _baseVOct += params[FINE_PARAM].getValue() / 12.0f;;
+ if (inputs[PITCH_INPUT].isConnected()) {
+ _baseVOct += clamp(inputs[PITCH_INPUT].getVoltage(), -5.0f, 5.0f);
}
if (_slowMode) {
_baseVOct -= 7.0f;
}
_baseHz = cvToFrequency(_baseVOct);
- float pw = params[SQUARE_PW_PARAM].value;
- if (inputs[SQUARE_PW_INPUT].active) {
- pw *= clamp(inputs[SQUARE_PW_INPUT].value / 5.0f, -1.0f, 1.0f);
+ float pw = params[SQUARE_PW_PARAM].getValue();
+ if (inputs[SQUARE_PW_INPUT].isConnected()) {
+ pw *= clamp(inputs[SQUARE_PW_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
}
pw *= 1.0f - 2.0f * _square.minPulseWidth;
pw *= 0.5f;
pw += 0.5f;
_square.setPulseWidth(_squarePulseWidthSL.next(pw));
- float saturation = params[SAW_SATURATION_PARAM].value;
- if (inputs[SAW_SATURATION_INPUT].active) {
- saturation *= clamp(inputs[SAW_SATURATION_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float saturation = params[SAW_SATURATION_PARAM].getValue();
+ if (inputs[SAW_SATURATION_INPUT].isConnected()) {
+ saturation *= clamp(inputs[SAW_SATURATION_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
_saw.setSaturation(_sawSaturationSL.next(saturation) * 10.f);
- float tsw = params[TRIANGLE_SAMPLE_PARAM].value * Phasor::maxSampleWidth;
- if (inputs[TRIANGLE_SAMPLE_INPUT].active) {
- tsw *= clamp(inputs[TRIANGLE_SAMPLE_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float tsw = params[TRIANGLE_SAMPLE_PARAM].getValue() * Phasor::maxSampleWidth;
+ if (inputs[TRIANGLE_SAMPLE_INPUT].isConnected()) {
+ tsw *= clamp(inputs[TRIANGLE_SAMPLE_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
_triangleSampleWidth = _triangleSampleWidthSL.next(tsw);
_triangle.setSampleWidth(_triangleSampleWidth);
- float sfb = params[SINE_FEEDBACK_PARAM].value;
- if (inputs[SINE_FEEDBACK_INPUT].active) {
- sfb *= clamp(inputs[SINE_FEEDBACK_INPUT].value / 10.0f, 0.0f, 1.0f);
+ float sfb = params[SINE_FEEDBACK_PARAM].getValue();
+ if (inputs[SINE_FEEDBACK_INPUT].isConnected()) {
+ sfb *= clamp(inputs[SINE_FEEDBACK_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
_sineFeedback = _sineFeedbackSL.next(sfb);
- _fmDepth = params[FM_DEPTH_PARAM].value;
- if (inputs[FM_DEPTH_INPUT].active) {
- _fmDepth *= clamp(inputs[FM_DEPTH_INPUT].value / 10.0f, 0.0f, 1.0f);
+ _fmDepth = params[FM_DEPTH_PARAM].getValue();
+ if (inputs[FM_DEPTH_INPUT].isConnected()) {
+ _fmDepth *= clamp(inputs[FM_DEPTH_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
}
_squarePhaseOffset = phaseOffset(params[SQUARE_PHASE_PARAM], inputs[SQUARE_PHASE_INPUT]);
@@ -84,15 +84,15 @@ void XCO::process(const ProcessArgs& args) {
_sineMix = level(params[SINE_MIX_PARAM], inputs[SINE_MIX_INPUT]);
}
- if (_syncTrigger.next(inputs[SYNC_INPUT].value)) {
+ if (_syncTrigger.next(inputs[SYNC_INPUT].getVoltage())) {
_phasor.resetPhase();
}
float frequency = _baseHz;
Phasor::phase_delta_t phaseOffset = 0;
float fmd = _fmDepthSL.next(_fmDepth);
- if (inputs[FM_INPUT].active && fmd > 0.01f) {
- float fm = inputs[FM_INPUT].value * fmd;
+ if (inputs[FM_INPUT].isConnected() && fmd > 0.01f) {
+ float fm = inputs[FM_INPUT].getVoltage() * fmd;
if (_fmLinearMode) {
phaseOffset = Phasor::radiansToPhase(2.0f * fm);
}
@@ -120,10 +120,10 @@ void XCO::process(const ProcessArgs& args) {
}
bool triangleSample = _triangleSampleWidth > 0.001f;
- bool squareActive = outputs[MIX_OUTPUT].active || outputs[SQUARE_OUTPUT].active;
- bool sawActive = outputs[MIX_OUTPUT].active || outputs[SAW_OUTPUT].active;
- bool triangleActive = outputs[MIX_OUTPUT].active || outputs[TRIANGLE_OUTPUT].active;
- bool sineActive = outputs[MIX_OUTPUT].active || outputs[SINE_OUTPUT].active;
+ bool squareActive = outputs[MIX_OUTPUT].isConnected() || outputs[SQUARE_OUTPUT].isConnected();
+ bool sawActive = outputs[MIX_OUTPUT].isConnected() || outputs[SAW_OUTPUT].isConnected();
+ bool triangleActive = outputs[MIX_OUTPUT].isConnected() || outputs[TRIANGLE_OUTPUT].isConnected();
+ bool sineActive = outputs[MIX_OUTPUT].isConnected() || outputs[SINE_OUTPUT].isConnected();
bool squareOversample = squareActive && oMix > 0.0f;
bool sawOversample = sawActive && oMix > 0.0f;
bool triangleOversample = triangleActive && (triangleSample || oMix > 0.0f);
@@ -197,12 +197,12 @@ void XCO::process(const ProcessArgs& args) {
sineOut += amplitude * (1.0f - _sineOMix) * _sine.nextFromPhasor(_phasor, sineFeedbackOffset + _sinePhaseOffset + phaseOffset);
}
- outputs[SQUARE_OUTPUT].value = squareOut;
- outputs[SAW_OUTPUT].value = sawOut;
- outputs[TRIANGLE_OUTPUT].value = triangleOut;
- outputs[SINE_OUTPUT].value = _sineFeedbackDelayedSample = sineOut;
- if (outputs[MIX_OUTPUT].active) {
- outputs[MIX_OUTPUT].value = _squareMixSL.next(_squareMix) * squareOut + _sawMixSL.next(_sawMix) * sawOut + _triangleMixSL.next(_triangleMix) * triangleOut + _sineMixSL.next(_sineMix) * sineOut;
+ outputs[SQUARE_OUTPUT].setVoltage(squareOut);
+ outputs[SAW_OUTPUT].setVoltage(sawOut);
+ outputs[TRIANGLE_OUTPUT].setVoltage(triangleOut);
+ outputs[SINE_OUTPUT].setVoltage(_sineFeedbackDelayedSample = sineOut);
+ if (outputs[MIX_OUTPUT].isConnected()) {
+ outputs[MIX_OUTPUT].setVoltage(_squareMixSL.next(_squareMix) * squareOut + _sawMixSL.next(_sawMix) * sawOut + _triangleMixSL.next(_triangleMix) * triangleOut + _sineMixSL.next(_sineMix) * sineOut);
}
}
diff --git a/src/XFade.cpp b/src/XFade.cpp
@@ -6,26 +6,26 @@ void XFade::onSampleRateChange() {
}
void XFade::process(const ProcessArgs& args) {
- bool linear = params[LINEAR_PARAM].value > 0.5f;
+ bool linear = params[LINEAR_PARAM].getValue() > 0.5f;
lights[LINEAR_LIGHT].value = linear;
- if (!outputs[OUT_OUTPUT].active) {
+ if (!outputs[OUT_OUTPUT].isConnected()) {
return;
}
- float mix = params[MIX_PARAM].value;
- if (inputs[MIX_INPUT].active) {
- mix *= clamp(inputs[MIX_INPUT].value / 5.0f, -1.0f, 1.0f);
+ float mix = params[MIX_PARAM].getValue();
+ if (inputs[MIX_INPUT].isConnected()) {
+ mix *= clamp(inputs[MIX_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
}
mix = _mixSL.next(mix);
- float curveIn = params[CURVE_PARAM].value;
+ float curveIn = params[CURVE_PARAM].getValue();
if (_linear != linear || _mix != mix || _curveIn != curveIn) {
_linear = linear;
_mix = mix;
_curveIn = curveIn;
if (!linear) {
- curveIn = powf(params[CURVE_PARAM].value, 0.082f);
+ curveIn = powf(params[CURVE_PARAM].getValue(), 0.082f);
}
curveIn *= 2.0f;
curveIn -= 1.0f;
@@ -33,7 +33,7 @@ void XFade::process(const ProcessArgs& args) {
_mixer.setParams(mix, curveIn, linear);
}
- outputs[OUT_OUTPUT].value = _mixer.next(inputs[A_INPUT].value, inputs[B_INPUT].value);
+ outputs[OUT_OUTPUT].setVoltage(_mixer.next(inputs[A_INPUT].getVoltage(), inputs[B_INPUT].getVoltage()));
}
struct XFadeWidget : ModuleWidget {
