VCVRack
/
Befaco
mirror of https://github.com/VCVRack/Befaco.git
1
0
Fork 0
Code Issues 0 Releases 17 Wiki Activity
Browse Source

Update to Rack v1 API

tags/v1.1.0
Andrew Belt 6 years ago
parent
e1c1a9ea0d
commit
3e239c08ce
6 changed files with 51 additions and 51 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +10
    -10
      src/ABC.cpp
  2. +4
    -4
      src/DualAtenuverter.cpp
  3. +9
    -9
      src/EvenVCO.cpp
  4. +15
    -15
      src/Rampage.cpp
  5. +5
    -5
      src/SlewLimiter.cpp
  6. +8
    -8
      src/SpringReverb.cpp

+ 10
- 10
src/ABC.cpp View File

@@ -47,25 +47,25 @@ struct ABC : Module {
}

void process(const ProcessArgs &args) override {
float a1 = inputs[A1_INPUT].value;
float b1 = inputs[B1_INPUT].getNormalVoltage(5.f) * 2.f*dsp::exponentialBipolar(80.f, params[B1_LEVEL_PARAM].value);
float c1 = inputs[C1_INPUT].getNormalVoltage(10.f) * dsp::exponentialBipolar(80.f, params[C1_LEVEL_PARAM].value);
float a1 = inputs[A1_INPUT].getVoltage();
float b1 = inputs[B1_INPUT].getNormalVoltage(5.f) * 2.f*dsp::exponentialBipolar(80.f, params[B1_LEVEL_PARAM].getValue());
float c1 = inputs[C1_INPUT].getNormalVoltage(10.f) * dsp::exponentialBipolar(80.f, params[C1_LEVEL_PARAM].getValue());
float out1 = a1 * b1 / 5.f + c1;

float a2 = inputs[A2_INPUT].value;
float b2 = inputs[B2_INPUT].getNormalVoltage(5.f) * 2.f*dsp::exponentialBipolar(80.f, params[B2_LEVEL_PARAM].value);
float c2 = inputs[C2_INPUT].getNormalVoltage(10.f) * dsp::exponentialBipolar(80.f, params[C2_LEVEL_PARAM].value);
float a2 = inputs[A2_INPUT].getVoltage();
float b2 = inputs[B2_INPUT].getNormalVoltage(5.f) * 2.f*dsp::exponentialBipolar(80.f, params[B2_LEVEL_PARAM].getValue());
float c2 = inputs[C2_INPUT].getNormalVoltage(10.f) * dsp::exponentialBipolar(80.f, params[C2_LEVEL_PARAM].getValue());
float out2 = a2 * b2 / 5.f + c2;

// Set outputs
if (outputs[OUT1_OUTPUT].active) {
outputs[OUT1_OUTPUT].value = clip(out1 / 10.f) * 10.f;
if (outputs[OUT1_OUTPUT].isConnected()) {
outputs[OUT1_OUTPUT].setVoltage(clip(out1 / 10.f) * 10.f);
}
else {
out2 += out1;
}
if (outputs[OUT2_OUTPUT].active) {
outputs[OUT2_OUTPUT].value = clip(out2 / 10.f) * 10.f;
if (outputs[OUT2_OUTPUT].isConnected()) {
outputs[OUT2_OUTPUT].setVoltage(clip(out2 / 10.f) * 10.f);
}

// Lights


+ 4
- 4
src/DualAtenuverter.cpp View File

@@ -36,13 +36,13 @@ struct DualAtenuverter : Module {
}

void process(const ProcessArgs &args) override {
float out1 = inputs[IN1_INPUT].value * params[ATEN1_PARAM].value + params[OFFSET1_PARAM].value;
float out2 = inputs[IN2_INPUT].value * params[ATEN2_PARAM].value + params[OFFSET2_PARAM].value;
float out1 = inputs[IN1_INPUT].getVoltage() * params[ATEN1_PARAM].getValue() + params[OFFSET1_PARAM].getValue();
float out2 = inputs[IN2_INPUT].getVoltage() * params[ATEN2_PARAM].getValue() + params[OFFSET2_PARAM].getValue();
out1 = clamp(out1, -10.f, 10.f);
out2 = clamp(out2, -10.f, 10.f);

outputs[OUT1_OUTPUT].value = out1;
outputs[OUT2_OUTPUT].value = out2;
outputs[OUT1_OUTPUT].setVoltage(out1);
outputs[OUT2_OUTPUT].setVoltage(out2);
lights[OUT1_POS_LIGHT].setSmoothBrightness(out1 / 5.f, args.sampleTime);
lights[OUT1_NEG_LIGHT].setSmoothBrightness(-out1 / 5.f, args.sampleTime);
lights[OUT2_POS_LIGHT].setSmoothBrightness(out2 / 5.f, args.sampleTime);


+ 9
- 9
src/EvenVCO.cpp View File

@@ -51,14 +51,14 @@ struct EvenVCO : Module {

void process(const ProcessArgs &args) override {
// Compute frequency, pitch is 1V/oct
float pitch = 1.f + std::round(params[OCTAVE_PARAM].value) + params[TUNE_PARAM].value / 12.f;
pitch += inputs[PITCH1_INPUT].value + inputs[PITCH2_INPUT].value;
pitch += inputs[FM_INPUT].value / 4.f;
float pitch = 1.f + std::round(params[OCTAVE_PARAM].getValue()) + params[TUNE_PARAM].getValue() / 12.f;
pitch += inputs[PITCH1_INPUT].getVoltage() + inputs[PITCH2_INPUT].getVoltage();
pitch += inputs[FM_INPUT].getVoltage() / 4.f;
float freq = dsp::FREQ_C4 * std::pow(2.f, pitch);
freq = clamp(freq, 0.f, 20000.f);

// Pulse width
float pw = params[PWM_PARAM].value + inputs[PWM_INPUT].value / 5.f;
float pw = params[PWM_PARAM].getValue() + inputs[PWM_INPUT].getVoltage() / 5.f;
const float minPw = 0.05;
pw = rescale(clamp(pw, -1.f, 1.f), -1.f, 1.f, minPw, 1.f - minPw);

@@ -108,11 +108,11 @@ struct EvenVCO : Module {
square += squareMinBlep.process();

// Set outputs
outputs[TRI_OUTPUT].value = 5.f*tri;
outputs[SINE_OUTPUT].value = 5.f*sine;
outputs[EVEN_OUTPUT].value = 5.f*even;
outputs[SAW_OUTPUT].value = 5.f*saw;
outputs[SQUARE_OUTPUT].value = 5.f*square;
outputs[TRI_OUTPUT].setVoltage(5.f*tri);
outputs[SINE_OUTPUT].setVoltage(5.f*sine);
outputs[EVEN_OUTPUT].setVoltage(5.f*even);
outputs[SAW_OUTPUT].setVoltage(5.f*saw);
outputs[SQUARE_OUTPUT].setVoltage(5.f*square);
}
};



+ 15
- 15
src/Rampage.cpp View File

@@ -97,20 +97,20 @@ struct Rampage : Module {

void process(const ProcessArgs &args) override {
for (int c = 0; c < 2; c++) {
float in = inputs[IN_A_INPUT + c].value;
if (trigger[c].process(params[TRIGG_A_PARAM + c].value * 10.0 + inputs[TRIGG_A_INPUT + c].value / 2.0)) {
float in = inputs[IN_A_INPUT + c].getVoltage();
if (trigger[c].process(params[TRIGG_A_PARAM + c].getValue() * 10.0 + inputs[TRIGG_A_INPUT + c].getVoltage() / 2.0)) {
gate[c] = true;
}
if (gate[c]) {
in = 10.0;
}

float shape = params[SHAPE_A_PARAM + c].value;
float shape = params[SHAPE_A_PARAM + c].getValue();
float delta = in - out[c];

// Integrator
float minTime;
switch ((int) params[RANGE_A_PARAM + c].value) {
switch ((int) params[RANGE_A_PARAM + c].getValue()) {
case 0: minTime = 1e-2; break;
case 1: minTime = 1e-3; break;
default: minTime = 1e-1; break;
@@ -121,7 +121,7 @@ struct Rampage : Module {

if (delta > 0) {
// Rise
float riseCv = params[RISE_A_PARAM + c].value - inputs[EXP_CV_A_INPUT + c].value / 10.0 + inputs[RISE_CV_A_INPUT + c].value / 10.0;
float riseCv = params[RISE_A_PARAM + c].getValue() - inputs[EXP_CV_A_INPUT + c].getVoltage() / 10.0 + inputs[RISE_CV_A_INPUT + c].getVoltage() / 10.0;
riseCv = clamp(riseCv, 0.0f, 1.0f);
float rise = minTime * std::pow(2.0, riseCv * 10.0);
out[c] += shapeDelta(delta, rise, shape) * args.sampleTime;
@@ -132,7 +132,7 @@ struct Rampage : Module {
}
else if (delta < 0) {
// Fall
float fallCv = params[FALL_A_PARAM + c].value - inputs[EXP_CV_A_INPUT + c].value / 10.0 + inputs[FALL_CV_A_INPUT + c].value / 10.0;
float fallCv = params[FALL_A_PARAM + c].getValue() - inputs[EXP_CV_A_INPUT + c].getVoltage() / 10.0 + inputs[FALL_CV_A_INPUT + c].getVoltage() / 10.0;
fallCv = clamp(fallCv, 0.0f, 1.0f);
float fall = minTime * std::pow(2.0, fallCv * 10.0);
out[c] += shapeDelta(delta, fall, shape) * args.sampleTime;
@@ -140,7 +140,7 @@ struct Rampage : Module {
if (!falling) {
// End of cycle, check if we should turn the gate back on (cycle mode)
endOfCyclePulse[c].trigger(1e-3);
if (params[CYCLE_A_PARAM + c].value * 10.0 + inputs[CYCLE_A_INPUT + c].value >= 4.0) {
if (params[CYCLE_A_PARAM + c].getValue() * 10.0 + inputs[CYCLE_A_INPUT + c].getVoltage() >= 4.0) {
gate[c] = true;
}
}
@@ -153,26 +153,26 @@ struct Rampage : Module {
out[c] = in;
}

outputs[RISING_A_OUTPUT + c].value = (rising ? 10.0 : 0.0);
outputs[FALLING_A_OUTPUT + c].value = (falling ? 10.0 : 0.0);
outputs[RISING_A_OUTPUT + c].setVoltage((rising ? 10.0 : 0.0));
outputs[FALLING_A_OUTPUT + c].setVoltage((falling ? 10.0 : 0.0));
lights[RISING_A_LIGHT + c].setSmoothBrightness(rising ? 1.0 : 0.0, args.sampleTime);
lights[FALLING_A_LIGHT + c].setSmoothBrightness(falling ? 1.0 : 0.0, args.sampleTime);
outputs[EOC_A_OUTPUT + c].value = (endOfCyclePulse[c].process(args.sampleTime) ? 10.0 : 0.0);
outputs[OUT_A_OUTPUT + c].value = out[c];
outputs[EOC_A_OUTPUT + c].setVoltage((endOfCyclePulse[c].process(args.sampleTime) ? 10.0 : 0.0));
outputs[OUT_A_OUTPUT + c].setVoltage(out[c]);
lights[OUT_A_LIGHT + c].setSmoothBrightness(out[c] / 10.0, args.sampleTime);
}

// Logic
float balance = params[BALANCE_PARAM].value;
float balance = params[BALANCE_PARAM].getValue();
float a = out[0];
float b = out[1];
if (balance < 0.5)
b *= 2.0 * balance;
else if (balance > 0.5)
a *= 2.0 * (1.0 - balance);
outputs[COMPARATOR_OUTPUT].value = (b > a ? 10.0 : 0.0);
outputs[MIN_OUTPUT].value = std::min(a, b);
outputs[MAX_OUTPUT].value = std::max(a, b);
outputs[COMPARATOR_OUTPUT].setVoltage((b > a ? 10.0 : 0.0));
outputs[MIN_OUTPUT].setVoltage(std::min(a, b));
outputs[MAX_OUTPUT].setVoltage(std::max(a, b));
// Lights
lights[COMPARATOR_LIGHT].setSmoothBrightness(outputs[COMPARATOR_OUTPUT].value / 10.0, args.sampleTime);
lights[MIN_LIGHT].setSmoothBrightness(outputs[MIN_OUTPUT].value / 10.0, args.sampleTime);


+ 5
- 5
src/SlewLimiter.cpp View File

@@ -29,8 +29,8 @@ struct SlewLimiter : Module {
}

void process(const ProcessArgs &args) override {
float in = inputs[IN_INPUT].value;
float shape = params[SHAPE_PARAM].value;
float in = inputs[IN_INPUT].getVoltage();
float shape = params[SHAPE_PARAM].getValue();

// minimum and maximum slopes in volts per second
const float slewMin = 0.1;
@@ -40,7 +40,7 @@ struct SlewLimiter : Module {

// Rise
if (in > out) {
float rise = inputs[RISE_INPUT].value / 10.f + params[RISE_PARAM].value;
float rise = inputs[RISE_INPUT].getVoltage() / 10.f + params[RISE_PARAM].getValue();
float slew = slewMax * std::pow(slewMin / slewMax, rise);
out += slew * crossfade(1.f, shapeScale * (in - out), shape) * args.sampleTime;
if (out > in)
@@ -48,14 +48,14 @@ struct SlewLimiter : Module {
}
// Fall
else if (in < out) {
float fall = inputs[FALL_INPUT].value / 10.f + params[FALL_PARAM].value;
float fall = inputs[FALL_INPUT].getVoltage() / 10.f + params[FALL_PARAM].getValue();
float slew = slewMax * std::pow(slewMin / slewMax, fall);
out -= slew * crossfade(1.f, shapeScale * (out - in), shape) * args.sampleTime;
if (out < in)
out = in;
}

outputs[OUT_OUTPUT].value = out;
outputs[OUT_OUTPUT].setVoltage(out);
}
};



+ 8
- 8
src/SpringReverb.cpp View File

@@ -65,16 +65,16 @@ struct SpringReverb : Module {
}

void process(const ProcessArgs &args) override {
float in1 = inputs[IN1_INPUT].value;
float in2 = inputs[IN2_INPUT].value;
float in1 = inputs[IN1_INPUT].getVoltage();
float in2 = inputs[IN2_INPUT].getVoltage();
const float levelScale = 0.030;
const float levelBase = 25.0;
float level1 = levelScale * dsp::exponentialBipolar(levelBase, params[LEVEL1_PARAM].value) * inputs[CV1_INPUT].getNormalVoltage(10.0) / 10.0;
float level2 = levelScale * dsp::exponentialBipolar(levelBase, params[LEVEL2_PARAM].value) * inputs[CV2_INPUT].getNormalVoltage(10.0) / 10.0;
float level1 = levelScale * dsp::exponentialBipolar(levelBase, params[LEVEL1_PARAM].getValue()) * inputs[CV1_INPUT].getNormalVoltage(10.0) / 10.0;
float level2 = levelScale * dsp::exponentialBipolar(levelBase, params[LEVEL2_PARAM].getValue()) * inputs[CV2_INPUT].getNormalVoltage(10.0) / 10.0;
float dry = in1 * level1 + in2 * level2;

// HPF on dry
float dryCutoff = 200.0 * std::pow(20.0, params[HPF_PARAM].value) * args.sampleTime;
float dryCutoff = 200.0 * std::pow(20.0, params[HPF_PARAM].getValue()) * args.sampleTime;
dryFilter.setCutoff(dryCutoff);
dryFilter.process(dry);

@@ -115,11 +115,11 @@ struct SpringReverb : Module {
if (outputBuffer.empty())
return;
float wet = outputBuffer.shift().samples[0];
float balance = clamp(params[WET_PARAM].value + inputs[MIX_CV_INPUT].value / 10.0f, 0.0f, 1.0f);
float balance = clamp(params[WET_PARAM].getValue() + inputs[MIX_CV_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
float mix = crossfade(in1, wet, balance);

outputs[WET_OUTPUT].value = clamp(wet, -10.0f, 10.0f);
outputs[MIX_OUTPUT].value = clamp(mix, -10.0f, 10.0f);
outputs[WET_OUTPUT].setVoltage(clamp(wet, -10.0f, 10.0f));
outputs[MIX_OUTPUT].setVoltage(clamp(mix, -10.0f, 10.0f));

// Set lights
float lightRate = 5.0 * args.sampleTime;


Write Preview
Loading…
Cancel
Save