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

Fix formatting and other code quality issues. Bump version to 1.1.0 instead of 1.0.1.

pull/13/head
Andrew Belt 5 years ago
parent
d97133aa2f
commit
4ad5689dca
10 changed files with 381 additions and 355 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +1
    -1
      plugin.json
  2. +65
    -59
      src/ABC.cpp
  3. +45
    -35
      src/DualAtenuverter.cpp
  4. +71
    -66
      src/EvenVCO.cpp
  5. +25
    -30
      src/Mixer.cpp
  6. +18
    -18
      src/PulseGenerator_4.hpp
  7. +110
    -103
      src/Rampage.cpp
  8. +14
    -15
      src/SlewLimiter.cpp
  9. +18
    -18
      src/SpringReverb.cpp
  10. +14
    -10
      src/simd_input.hpp

+ 1
- 1
plugin.json View File

@@ -1,6 +1,6 @@
{
"slug": "Befaco",
"version": "1.0.1",
"version": "1.1.0",
"license": "BSD-3-Clause",
"name": "Befaco",
"author": "VCV",


+ 65
- 59
src/ABC.cpp View File

@@ -2,30 +2,19 @@
#include "simd_input.hpp"


static simd::float_4 clip4(simd::float_4 x) {
template <typename T>
static T clip4(T x) {
// Pade approximant of x/(1 + x^12)^(1/12)
const simd::float_4 limit = simd::float_4(1.16691853009184);
const simd::float_4 cnst_10 = simd::float_4(10.0);
const simd::float_4 cnst_1 = simd::float_4(1.0);
const simd::float_4 cnst_01 = simd::float_4(0.1);

const simd::float_4 coeff_1 = simd::float_4(1.45833);
const simd::float_4 coeff_2 = simd::float_4(0.559028);
const simd::float_4 coeff_3 = simd::float_4(0.0427035);
const simd::float_4 coeff_4 = simd::float_4(1.54167);
const simd::float_4 coeff_5 = simd::float_4(0.642361);
const simd::float_4 coeff_6 = simd::float_4(0.0579909);

x = clamp(x*cnst_01, -limit, limit);
return cnst_10 * (x + coeff_1*simd::pow(x, 13) + coeff_2*simd::pow(x, 25) + coeff_3*simd::pow(x, 37))
/ (cnst_1 + coeff_4*simd::pow(x, 12) + coeff_5*simd::pow(x, 24) + coeff_6*simd::pow(x, 36));
const T limit = 1.16691853009184f;
x = clamp(x * 0.1f, -limit, limit);
return 10.0f * (x + 1.45833f * simd::pow(x, 13) + 0.559028f * simd::pow(x, 25) + 0.0427035f * simd::pow(x, 37))
/ (1.0f + 1.54167f * simd::pow(x, 12) + 0.642361f * simd::pow(x, 24) + 0.0579909f * simd::pow(x, 36));
}


static float exponentialBipolar80Pade_5_4(float x) {
return (0.109568*x + 0.281588*std::pow(x, 3) + 0.133841*std::pow(x, 5))
/ (1. - 0.630374*std::pow(x, 2) + 0.166271*std::pow(x, 4));
return (0.109568 * x + 0.281588 * std::pow(x, 3) + 0.133841 * std::pow(x, 5))
/ (1. - 0.630374 * std::pow(x, 2) + 0.166271 * std::pow(x, 4));
}


@@ -57,7 +46,6 @@ struct ABC : Module {
NUM_LIGHTS
};


ABC() {
config(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS);
configParam(B1_LEVEL_PARAM, -1.0, 1.0, 0.0, "B1 Level");
@@ -66,7 +54,6 @@ struct ABC : Module {
configParam(C2_LEVEL_PARAM, -1.0, 1.0, 0.0, "C2 Level");
}


void process(const ProcessArgs &args) override {

simd::float_4 a1[4] = {};
@@ -87,7 +74,7 @@ struct ABC : Module {

// process upper section

if(outputs[OUT1_OUTPUT].isConnected() || outputs[OUT2_OUTPUT].isConnected() ) {
if (outputs[OUT1_OUTPUT].isConnected() || outputs[OUT2_OUTPUT].isConnected()) {

int channels_A1 = inputs[A1_INPUT].getChannels();
int channels_B1 = inputs[B1_INPUT].getChannels();
@@ -97,33 +84,41 @@ struct ABC : Module {
channels_1 = std::max(channels_1, channels_B1);
channels_1 = std::max(channels_1, channels_C1);

float mult_B1 = (2.f/5.f)*exponentialBipolar80Pade_5_4(params[B1_LEVEL_PARAM].getValue());
float mult_B1 = (2.f / 5.f) * exponentialBipolar80Pade_5_4(params[B1_LEVEL_PARAM].getValue());
float mult_C1 = exponentialBipolar80Pade_5_4(params[C1_LEVEL_PARAM].getValue());

if(inputs[A1_INPUT].isConnected()) load_input(inputs[A1_INPUT], a1, channels_A1);
else memset(a1, 0, sizeof(a1));
if (inputs[A1_INPUT].isConnected())
load_input(inputs[A1_INPUT], a1, channels_A1);
else
memset(a1, 0, sizeof(a1));

if(inputs[B1_INPUT].isConnected()) {
if (inputs[B1_INPUT].isConnected()) {
load_input(inputs[B1_INPUT], b1, channels_B1);
for(int c=0; c<channels_1; c+=4) b1[c/4] *= simd::float_4(mult_B1);
} else {
for(int c=0; c<channels_1; c+=4) b1[c/4] = simd::float_4(5.f*mult_B1);
for (int c = 0; c < channels_1; c += 4)
b1[c / 4] *= simd::float_4(mult_B1);
}
else {
for (int c = 0; c < channels_1; c += 4)
b1[c / 4] = simd::float_4(5.f * mult_B1);
}

if(inputs[C1_INPUT].isConnected()) {
if (inputs[C1_INPUT].isConnected()) {
load_input(inputs[C1_INPUT], c1, channels_C1);
for(int c=0; c<channels_1; c+=4) c1[c/4] *= simd::float_4(mult_C1);
} else {
for(int c=0; c<channels_1; c+=4) c1[c/4] = simd::float_4(10.f*mult_C1);
for (int c = 0; c < channels_1; c += 4)
c1[c / 4] *= simd::float_4(mult_C1);
}
else {
for (int c = 0; c < channels_1; c += 4)
c1[c / 4] = simd::float_4(10.f * mult_C1);
}

for(int c=0; c<channels_1; c+=4) out1[c/4] = clip4(a1[c/4] * b1[c/4] + c1[c/4]);
for (int c = 0; c < channels_1; c += 4)
out1[c / 4] = clip4(a1[c / 4] * b1[c / 4] + c1[c / 4]);
}

// process lower section

if(outputs[OUT2_OUTPUT].isConnected()) {

if (outputs[OUT2_OUTPUT].isConnected()) {
int channels_A2 = inputs[A2_INPUT].getChannels();
int channels_B2 = inputs[B2_INPUT].getChannels();
int channels_C2 = inputs[C2_INPUT].getChannels();
@@ -132,43 +127,54 @@ struct ABC : Module {
channels_2 = std::max(channels_2, channels_B2);
channels_2 = std::max(channels_2, channels_C2);

float mult_B2 = (2.f/5.f)*exponentialBipolar80Pade_5_4(params[B2_LEVEL_PARAM].getValue());
float mult_B2 = (2.f / 5.f) * exponentialBipolar80Pade_5_4(params[B2_LEVEL_PARAM].getValue());
float mult_C2 = exponentialBipolar80Pade_5_4(params[C2_LEVEL_PARAM].getValue());

if(inputs[A2_INPUT].isConnected()) load_input(inputs[A2_INPUT], a2, channels_A2);
else memset(a2, 0, sizeof(a2));
if (inputs[A2_INPUT].isConnected())
load_input(inputs[A2_INPUT], a2, channels_A2);
else
memset(a2, 0, sizeof(a2));

if(inputs[B2_INPUT].isConnected()) {
if (inputs[B2_INPUT].isConnected()) {
load_input(inputs[B2_INPUT], b2, channels_B2);
for(int c=0; c<channels_2; c+=4) b2[c/4] *= simd::float_4(mult_B2);
} else {
for(int c=0; c<channels_2; c+=4) b2[c/4] = simd::float_4(5.f*mult_B2);
for (int c = 0; c < channels_2; c += 4)
b2[c / 4] *= simd::float_4(mult_B2);
}
else {
for (int c = 0; c < channels_2; c += 4)
b2[c / 4] = simd::float_4(5.f * mult_B2);
}

if(inputs[C2_INPUT].isConnected()) {
if (inputs[C2_INPUT].isConnected()) {
load_input(inputs[C2_INPUT], c2, channels_C2);
for(int c=0; c<channels_2; c+=4) c2[c/4] *= simd::float_4(mult_C2);
} else {
for(int c=0; c<channels_2; c+=4) c2[c/4] = simd::float_4(10.f*mult_C2);
for (int c = 0; c < channels_2; c += 4)
c2[c / 4] *= simd::float_4(mult_C2);
}
else {
for (int c = 0; c < channels_2; c += 4)
c2[c / 4] = simd::float_4(10.f * mult_C2);
}

for(int c=0; c<channels_2; c+=4) out2[c/4] = clip4(a2[c/4] * b2[c/4] + c2[c/4]);
for (int c = 0; c < channels_2; c += 4)
out2[c / 4] = clip4(a2[c / 4] * b2[c / 4] + c2[c / 4]);
};


// Set outputs
if (outputs[OUT1_OUTPUT].isConnected()) {
outputs[OUT1_OUTPUT].setChannels(channels_1);
for(int c=0; c<channels_1; c+=4) out1[c/4].store(outputs[OUT1_OUTPUT].getVoltages(c));
for (int c = 0; c < channels_1; c += 4)
out1[c / 4].store(outputs[OUT1_OUTPUT].getVoltages(c));
}
else {
for(int c=0; c<channels_1; c+=4) out2[c/4] += out1[c/4];
for (int c = 0; c < channels_1; c += 4)
out2[c / 4] += out1[c / 4];
channels_2 = std::max(channels_1, channels_2);
}

if (outputs[OUT2_OUTPUT].isConnected()) {
outputs[OUT2_OUTPUT].setChannels(channels_2);
for(int c=0; c<channels_2; c+=4) out2[c/4].store(outputs[OUT2_OUTPUT].getVoltages(c));
for (int c = 0; c < channels_2; c += 4)
out2[c / 4].store(outputs[OUT2_OUTPUT].getVoltages(c));
}

// Lights
@@ -176,31 +182,31 @@ struct ABC : Module {
float light_1;
float light_2;

if(channels_1==1) {
if (channels_1 == 1) {
light_1 = out1[0].s[0];
lights[OUT1_LIGHT + 0].setSmoothBrightness(light_1 / 5.f, args.sampleTime);
lights[OUT1_LIGHT + 1].setSmoothBrightness(-light_1 / 5.f, args.sampleTime);
lights[OUT1_LIGHT + 2].setBrightness(0.f);
} else {
}
else {
light_1 = 10.f;
lights[OUT1_LIGHT + 0].setBrightness(0.0f);
lights[OUT1_LIGHT + 1].setBrightness(0.0f);
lights[OUT1_LIGHT + 2].setBrightness(light_1);
}

if(channels_2==1) {
if (channels_2 == 1) {
light_2 = out2[0].s[0];
lights[OUT2_LIGHT + 0].setSmoothBrightness(light_2 / 5.f, args.sampleTime);
lights[OUT2_LIGHT + 1].setSmoothBrightness(-light_2 / 5.f, args.sampleTime);
lights[OUT2_LIGHT + 2].setBrightness(0.f);
} else {
}
else {
light_2 = 10.f;
lights[OUT2_LIGHT + 0].setBrightness(0.0f);
lights[OUT2_LIGHT + 1].setBrightness(0.0f);
lights[OUT2_LIGHT + 2].setBrightness(light_2);
}

}
}
};



+ 45
- 35
src/DualAtenuverter.cpp View File

@@ -35,53 +35,63 @@ struct DualAtenuverter : Module {
}

void process(const ProcessArgs &args) override {
using simd::float_4;

simd::float_4 out1[4];
simd::float_4 out2[4];
float_4 out1[4];
float_4 out2[4];

int channels1 = inputs[IN1_INPUT].getChannels(); channels1 = channels1>0?channels1:1;
int channels2 = inputs[IN2_INPUT].getChannels(); channels2 = channels2>0?channels2:1;
int channels1 = inputs[IN1_INPUT].getChannels();
channels1 = channels1 > 0 ? channels1 : 1;
int channels2 = inputs[IN2_INPUT].getChannels();
channels2 = channels2 > 0 ? channels2 : 1;

simd::float_4 att1 = simd::float_4(params[ATEN1_PARAM].getValue());
simd::float_4 att2 = simd::float_4(params[ATEN2_PARAM].getValue());
float att1 = params[ATEN1_PARAM].getValue();
float att2 = params[ATEN2_PARAM].getValue();

simd::float_4 offset1 = simd::float_4(params[OFFSET1_PARAM].getValue());
simd::float_4 offset2 = simd::float_4(params[OFFSET2_PARAM].getValue());
float offset1 = params[OFFSET1_PARAM].getValue();
float offset2 = params[OFFSET2_PARAM].getValue();

for (int c = 0; c < channels1; c += 4) {
out1[c / 4] = clamp(float_4::load(inputs[IN1_INPUT].getVoltages(c)) * att1 + offset1, -10.f, 10.f);
}
for (int c = 0; c < channels2; c += 4) {
out2[c / 4] = clamp(float_4::load(inputs[IN2_INPUT].getVoltages(c)) * att2 + offset2, -10.f, 10.f);
}

for (int c = 0; c < channels1; c += 4) out1[c / 4] = clamp(simd::float_4::load(inputs[IN1_INPUT].getVoltages(c)) * att1 + offset1, -10.f, 10.f);
for (int c = 0; c < channels2; c += 4) out2[c / 4] = clamp(simd::float_4::load(inputs[IN2_INPUT].getVoltages(c)) * att2 + offset2, -10.f, 10.f);
outputs[OUT1_OUTPUT].setChannels(channels1);
outputs[OUT2_OUTPUT].setChannels(channels2);
for (int c = 0; c < channels1; c += 4) out1[c / 4].store(outputs[OUT1_OUTPUT].getVoltages(c));
for (int c = 0; c < channels2; c += 4) out2[c / 4].store(outputs[OUT2_OUTPUT].getVoltages(c));
float light1 = outputs[OUT1_OUTPUT].getVoltageSum()/channels1;
float light2 = outputs[OUT2_OUTPUT].getVoltageSum()/channels2;

if(channels1==1) {
lights[OUT1_LIGHT ].setSmoothBrightness(light1 / 5.f, args.sampleTime);
lights[OUT1_LIGHT+1].setSmoothBrightness(-light1 / 5.f, args.sampleTime);
lights[OUT1_LIGHT+2].setBrightness(0.0f);
} else {
lights[OUT1_LIGHT ].setBrightness(0.0f);
lights[OUT1_LIGHT+1].setBrightness(0.0f);
lights[OUT1_LIGHT+2].setBrightness(10.0f);
}

if(channels2==1) {
lights[OUT2_LIGHT ].setSmoothBrightness(light2 / 5.f, args.sampleTime);
lights[OUT2_LIGHT+1].setSmoothBrightness(-light2 / 5.f, args.sampleTime);
lights[OUT2_LIGHT+2].setBrightness(0.0f);
} else {
lights[OUT2_LIGHT ].setBrightness(0.0f);
lights[OUT2_LIGHT+1].setBrightness(0.0f);
lights[OUT2_LIGHT+2].setBrightness(10.0f);
for (int c = 0; c < channels1; c += 4) {
out1[c / 4].store(outputs[OUT1_OUTPUT].getVoltages(c));
}
for (int c = 0; c < channels2; c += 4) {
out2[c / 4].store(outputs[OUT2_OUTPUT].getVoltages(c));
}

float light1 = outputs[OUT1_OUTPUT].getVoltageSum() / channels1;
float light2 = outputs[OUT2_OUTPUT].getVoltageSum() / channels2;

if (channels1 == 1) {
lights[OUT1_LIGHT + 0].setSmoothBrightness(light1 / 5.f, args.sampleTime);
lights[OUT1_LIGHT + 1].setSmoothBrightness(-light1 / 5.f, args.sampleTime);
lights[OUT1_LIGHT + 2].setBrightness(0.0f);
}
else {
lights[OUT1_LIGHT + 0].setBrightness(0.0f);
lights[OUT1_LIGHT + 1].setBrightness(0.0f);
lights[OUT1_LIGHT + 2].setBrightness(10.0f);
}

if (channels2 == 1) {
lights[OUT2_LIGHT + 0].setSmoothBrightness(light2 / 5.f, args.sampleTime);
lights[OUT2_LIGHT + 1].setSmoothBrightness(-light2 / 5.f, args.sampleTime);
lights[OUT2_LIGHT + 2].setBrightness(0.0f);
}
else {
lights[OUT2_LIGHT + 0].setBrightness(0.0f);
lights[OUT2_LIGHT + 1].setBrightness(0.0f);
lights[OUT2_LIGHT + 2].setBrightness(10.0f);
}
}
};



+ 71
- 66
src/EvenVCO.cpp View File

@@ -49,21 +49,21 @@ struct EvenVCO : Module {
configParam(OCTAVE_PARAM, -5.0, 4.0, 0.0, "Octave", "'", 0.5);
configParam(TUNE_PARAM, -7.0, 7.0, 0.0, "Tune", " semitones");
configParam(PWM_PARAM, -1.0, 1.0, 0.0, "Pulse width");
for(int i=0; i<4; i++) {
for (int i = 0; i < 4; i++) {
phase[i] = simd::float_4(0.0f);
tri[i] = simd::float_4(0.0f);
}
for(int c=0; c<PORT_MAX_CHANNELS; c++) halfPhase[c] = false;
for (int c = 0; c < PORT_MAX_CHANNELS; c++)
halfPhase[c] = false;
}

void process(const ProcessArgs &args) override {

simd::float_4 pitch[4];
simd::float_4 pitch[4];
simd::float_4 pitch_1[4];
simd::float_4 pitch_2[4];
simd::float_4 pitch_fm[4];
simd::float_4 freq[4];
simd::float_4 freq[4];
simd::float_4 pw[4];
simd::float_4 pwm[4];
simd::float_4 deltaPhase[4];
@@ -82,26 +82,30 @@ struct EvenVCO : Module {

// Compute frequency, pitch is 1V/oct

for(int c=0; c<channels; c+=4) pitch[c/4] = simd::float_4(pitch_0);
for (int c = 0; c < channels; c += 4)
pitch[c / 4] = simd::float_4(pitch_0);

if(inputs[PITCH1_INPUT].isConnected()) {
if (inputs[PITCH1_INPUT].isConnected()) {
load_input(inputs[PITCH1_INPUT], pitch_1, channels_pitch1);
for(int c=0; c<channels_pitch1; c+=4) pitch[c/4] += pitch_1[c/4];
for (int c = 0; c < channels_pitch1; c += 4)
pitch[c / 4] += pitch_1[c / 4];
}

if(inputs[PITCH2_INPUT].isConnected()) {
if (inputs[PITCH2_INPUT].isConnected()) {
load_input(inputs[PITCH2_INPUT], pitch_2, channels_pitch2);
for(int c=0; c<channels_pitch2; c+=4) pitch[c/4] += pitch_2[c/4];
for (int c = 0; c < channels_pitch2; c += 4)
pitch[c / 4] += pitch_2[c / 4];
}

if(inputs[FM_INPUT].isConnected()) {
if (inputs[FM_INPUT].isConnected()) {
load_input(inputs[FM_INPUT], pitch_fm, channels_fm);
for(int c=0; c<channels_fm; c+=4) pitch[c/4] += pitch_fm[c/4] / 4.f;
for (int c = 0; c < channels_fm; c += 4)
pitch[c / 4] += pitch_fm[c / 4] / 4.f;
}

for(int c=0; c<channels; c+=4) {
freq[c/4] = dsp::FREQ_C4 * simd::pow(2.f, pitch[c/4]);
freq[c/4] = clamp(freq[c/4], 0.f, 20000.f);
for (int c = 0; c < channels; c += 4) {
freq[c / 4] = dsp::FREQ_C4 * simd::pow(2.f, pitch[c / 4]);
freq[c / 4] = clamp(freq[c / 4], 0.f, 20000.f);
}


@@ -109,46 +113,48 @@ struct EvenVCO : Module {

float pw_0 = params[PWM_PARAM].getValue();

for(int c=0; c<channels; c+=4) pw[c/4] = simd::float_4(pw_0);
if(inputs[PWM_INPUT].isConnected()) {
for (int c = 0; c < channels; c += 4)
pw[c / 4] = simd::float_4(pw_0);

if (inputs[PWM_INPUT].isConnected()) {
load_input(inputs[PWM_INPUT], pwm, channels_pwm);
for(int c=0; c<channels_pwm; c+=4) pw[c/4] += pwm[c/4] / 5.f;
for (int c = 0; c < channels_pwm; c += 4)
pw[c / 4] += pwm[c / 4] / 5.f;
}

const simd::float_4 minPw_4 = simd::float_4(0.05f);
const simd::float_4 m_one_4 = simd::float_4(-1.0f);
const simd::float_4 one_4 = simd::float_4(1.0f);

for(int c=0; c<channels; c+=4) {
pw[c/4] = rescale(clamp(pw[c/4], m_one_4, one_4), m_one_4, one_4, minPw_4, one_4 - minPw_4);
for (int c = 0; c < channels; c += 4) {
pw[c / 4] = rescale(clamp(pw[c / 4], m_one_4, one_4), m_one_4, one_4, minPw_4, one_4 - minPw_4);

// Advance phase
deltaPhase[c/4] = clamp(freq[c/4] * args.sampleTime, simd::float_4(1e-6f), simd::float_4(0.5f));
oldPhase[c/4] = phase[c/4];
phase[c/4] += deltaPhase[c/4];
deltaPhase[c / 4] = clamp(freq[c / 4] * args.sampleTime, simd::float_4(1e-6f), simd::float_4(0.5f));
oldPhase[c / 4] = phase[c / 4];
phase[c / 4] += deltaPhase[c / 4];
}

// the next block can't be done with SIMD instructions:

for(int c=0; c<channels; c++) {
for (int c = 0; c < channels; c++) {

if (oldPhase[c/4].s[c%4] < 0.5 && phase[c/4].s[c%4] >= 0.5) {
float crossing = -(phase[c/4].s[c%4] - 0.5) / deltaPhase[c/4].s[c%4];
if (oldPhase[c / 4].s[c % 4] < 0.5 && phase[c / 4].s[c % 4] >= 0.5) {
float crossing = -(phase[c / 4].s[c % 4] - 0.5) / deltaPhase[c / 4].s[c % 4];
triSquareMinBlep[c].insertDiscontinuity(crossing, 2.f);
doubleSawMinBlep[c].insertDiscontinuity(crossing, -2.f);
}

if (!halfPhase[c] && phase[c/4].s[c%4] >= pw[c/4].s[c%4]) {
float crossing = -(phase[c/4].s[c%4] - pw[c/4].s[c%4]) / deltaPhase[c/4].s[c%4];
if (!halfPhase[c] && phase[c / 4].s[c % 4] >= pw[c / 4].s[c % 4]) {
float crossing = -(phase[c / 4].s[c % 4] - pw[c / 4].s[c % 4]) / deltaPhase[c / 4].s[c % 4];
squareMinBlep[c].insertDiscontinuity(crossing, 2.f);
halfPhase[c] = true;
}
}

// Reset phase if at end of cycle
if (phase[c/4].s[c%4] >= 1.f) {
phase[c/4].s[c%4] -= 1.f;
float crossing = -phase[c/4].s[c%4] / deltaPhase[c/4].s[c%4];
if (phase[c / 4].s[c % 4] >= 1.f) {
phase[c / 4].s[c % 4] -= 1.f;
float crossing = -phase[c / 4].s[c % 4] / deltaPhase[c / 4].s[c % 4];
triSquareMinBlep[c].insertDiscontinuity(crossing, -2.f);
doubleSawMinBlep[c].insertDiscontinuity(crossing, -2.f);
squareMinBlep[c].insertDiscontinuity(crossing, -2.f);
@@ -171,11 +177,11 @@ struct EvenVCO : Module {
simd::float_4 square[4];
simd::float_4 triOut[4];

for(int c=0; c<channels; c++) {
triSquareMinBlepOut[c/4].s[c%4] = triSquareMinBlep[c].process();
doubleSawMinBlepOut[c/4].s[c%4] = doubleSawMinBlep[c].process();
sawMinBlepOut[c/4].s[c%4] = sawMinBlep[c].process();
squareMinBlepOut[c/4].s[c%4] = squareMinBlep[c].process();
for (int c = 0; c < channels; c++) {
triSquareMinBlepOut[c / 4].s[c % 4] = triSquareMinBlep[c].process();
doubleSawMinBlepOut[c / 4].s[c % 4] = doubleSawMinBlep[c].process();
sawMinBlepOut[c / 4].s[c % 4] = sawMinBlep[c].process();
squareMinBlepOut[c / 4].s[c % 4] = squareMinBlep[c].process();
}

// Outputs
@@ -186,40 +192,39 @@ struct EvenVCO : Module {
outputs[SAW_OUTPUT].setChannels(channels);
outputs[SQUARE_OUTPUT].setChannels(channels);

for(int c=0; c<channels; c+=4) {
triSquare[c/4] = simd::ifelse( (phase[c/4] < 0.5f*one_4), m_one_4, one_4);
triSquare[c/4] += triSquareMinBlepOut[c/4];
for (int c = 0; c < channels; c += 4) {
triSquare[c / 4] = simd::ifelse((phase[c / 4] < 0.5f * one_4), m_one_4, one_4);
triSquare[c / 4] += triSquareMinBlepOut[c / 4];

// Integrate square for triangle
tri[c/4] += (4.f * triSquare[c/4]) * (freq[c/4] * args.sampleTime);
tri[c/4] *= (1.f - 40.f * args.sampleTime);
triOut[c/4] = 5.f * tri[c/4];

tri[c / 4] += (4.f * triSquare[c / 4]) * (freq[c / 4] * args.sampleTime);
tri[c / 4] *= (1.f - 40.f * args.sampleTime);
triOut[c / 4] = 5.f * tri[c / 4];

sine[c / 4] = 5.f * simd::cos(2 * M_PI * phase[c / 4]);

sine[c/4] = 5.f * simd::cos(2*M_PI * phase[c/4]);
doubleSaw[c/4] = simd::ifelse( (phase[c/4] < 0.5), (-1.f + 4.f*phase[c/4]), (-1.f + 4.f*(phase[c/4] - 0.5f)));
doubleSaw[c/4] += doubleSawMinBlepOut[c/4];
doubleSaw[c/4] *= 5.f;
doubleSaw[c / 4] = simd::ifelse((phase[c / 4] < 0.5), (-1.f + 4.f * phase[c / 4]), (-1.f + 4.f * (phase[c / 4] - 0.5f)));
doubleSaw[c / 4] += doubleSawMinBlepOut[c / 4];
doubleSaw[c / 4] *= 5.f;

even[c/4] = 0.55 * (doubleSaw[c/4] + 1.27 * sine[c/4]);
saw[c/4] = -1.f + 2.f*phase[c/4];
saw[c/4] += sawMinBlepOut[c/4];
saw[c/4] *= 5.f;
even[c / 4] = 0.55 * (doubleSaw[c / 4] + 1.27 * sine[c / 4]);
saw[c / 4] = -1.f + 2.f * phase[c / 4];
saw[c / 4] += sawMinBlepOut[c / 4];
saw[c / 4] *= 5.f;

square[c/4] = simd::ifelse( (phase[c/4] < pw[c/4]), m_one_4, one_4) ;
square[c/4] += squareMinBlepOut[c/4];
square[c/4] *= 5.f;
square[c / 4] = simd::ifelse((phase[c / 4] < pw[c / 4]), m_one_4, one_4) ;
square[c / 4] += squareMinBlepOut[c / 4];
square[c / 4] *= 5.f;

// Set outputs

triOut[c/4].store(outputs[TRI_OUTPUT].getVoltages(c));
sine[c/4].store(outputs[SINE_OUTPUT].getVoltages(c));
even[c/4].store(outputs[EVEN_OUTPUT].getVoltages(c));
saw[c/4].store(outputs[SAW_OUTPUT].getVoltages(c));
square[c/4].store(outputs[SQUARE_OUTPUT].getVoltages(c));
triOut[c / 4].store(outputs[TRI_OUTPUT].getVoltages(c));
sine[c / 4].store(outputs[SINE_OUTPUT].getVoltages(c));
even[c / 4].store(outputs[EVEN_OUTPUT].getVoltages(c));
saw[c / 4].store(outputs[SAW_OUTPUT].getVoltages(c));
square[c / 4].store(outputs[SQUARE_OUTPUT].getVoltages(c));
}
}
};
@@ -232,8 +237,8 @@ struct EvenVCOWidget : ModuleWidget {

addChild(createWidget<Knurlie>(Vec(15, 0)));
addChild(createWidget<Knurlie>(Vec(15, 365)));
addChild(createWidget<Knurlie>(Vec(15*6, 0)));
addChild(createWidget<Knurlie>(Vec(15*6, 365)));
addChild(createWidget<Knurlie>(Vec(15 * 6, 0)));
addChild(createWidget<Knurlie>(Vec(15 * 6, 365)));

addParam(createParam<BefacoBigSnapKnob>(Vec(22, 32), module, EvenVCO::OCTAVE_PARAM));
addParam(createParam<BefacoTinyKnob>(Vec(73, 131), module, EvenVCO::TUNE_PARAM));


+ 25
- 30
src/Mixer.cpp View File

@@ -2,7 +2,6 @@
#include "simd_input.hpp"



struct Mixer : Module {
enum ParamIds {
CH1_PARAM,
@@ -30,21 +29,15 @@ struct Mixer : Module {
NUM_LIGHTS
};

simd::float_4 minus_one;

Mixer() {
config(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS);
configParam(CH1_PARAM, 0.0, 1.0, 0.0, "Ch 1 level", "%", 0, 100);
configParam(CH2_PARAM, 0.0, 1.0, 0.0, "Ch 2 level", "%", 0, 100);
configParam(CH3_PARAM, 0.0, 1.0, 0.0, "Ch 3 level", "%", 0, 100);
configParam(CH4_PARAM, 0.0, 1.0, 0.0, "Ch 4 level", "%", 0, 100);

minus_one = simd::float_4(-1.0f);
}


void process(const ProcessArgs &args) override {

int channels1 = inputs[IN1_INPUT].getChannels();
int channels2 = inputs[IN2_INPUT].getChannels();
int channels3 = inputs[IN3_INPUT].getChannels();
@@ -55,66 +48,68 @@ struct Mixer : Module {
out_channels = std::max(out_channels, channels2);
out_channels = std::max(out_channels, channels3);
out_channels = std::max(out_channels, channels4);
simd::float_4 mult1 = simd::float_4(params[CH1_PARAM].getValue());
simd::float_4 mult2 = simd::float_4(params[CH2_PARAM].getValue());
simd::float_4 mult3 = simd::float_4(params[CH3_PARAM].getValue());
simd::float_4 mult4 = simd::float_4(params[CH4_PARAM].getValue());

simd::float_4 out[4];
simd::float_4 out[4];

memset(out, 0, sizeof(out));
std::memset(out, 0, sizeof(out));


if(inputs[IN1_INPUT].isConnected()) {
for(int c=0; c<channels1; c+=4) out[c/4] += simd::float_4::load(inputs[IN1_INPUT].getVoltages(c)) * mult1;
if (inputs[IN1_INPUT].isConnected()) {
for (int c = 0; c < channels1; c += 4)
out[c / 4] += simd::float_4::load(inputs[IN1_INPUT].getVoltages(c)) * mult1;
}
if(inputs[IN2_INPUT].isConnected()) {
for(int c=0; c<channels2; c+=4) out[c/4] += simd::float_4::load(inputs[IN2_INPUT].getVoltages(c)) * mult2;

if (inputs[IN2_INPUT].isConnected()) {
for (int c = 0; c < channels2; c += 4)
out[c / 4] += simd::float_4::load(inputs[IN2_INPUT].getVoltages(c)) * mult2;
}

if(inputs[IN3_INPUT].isConnected()) {
for(int c=0; c<channels3; c+=4) out[c/4] += simd::float_4::load(inputs[IN3_INPUT].getVoltages(c)) * mult3;
if (inputs[IN3_INPUT].isConnected()) {
for (int c = 0; c < channels3; c += 4)
out[c / 4] += simd::float_4::load(inputs[IN3_INPUT].getVoltages(c)) * mult3;
}

if(inputs[IN4_INPUT].isConnected()) {
for(int c=0; c<channels4; c+=4) out[c/4] += simd::float_4::load(inputs[IN4_INPUT].getVoltages(c)) * mult4;
if (inputs[IN4_INPUT].isConnected()) {
for (int c = 0; c < channels4; c += 4)
out[c / 4] += simd::float_4::load(inputs[IN4_INPUT].getVoltages(c)) * mult4;
}


outputs[OUT1_OUTPUT].setChannels(out_channels);
outputs[OUT2_OUTPUT].setChannels(out_channels);

for(int c=0; c<out_channels; c+=4) {
for (int c = 0; c < out_channels; c += 4) {
out[c / 4].store(outputs[OUT1_OUTPUT].getVoltages(c));
out[c / 4] *= minus_one;
out[c / 4] *= -1.f;
out[c / 4].store(outputs[OUT2_OUTPUT].getVoltages(c));
}

if(out_channels==1) {
if (out_channels == 1) {
float light = outputs[OUT1_OUTPUT].getVoltage();
lights[OUT_POS_LIGHT].setSmoothBrightness(light / 5.f, args.sampleTime);
lights[OUT_NEG_LIGHT].setSmoothBrightness(-light / 5.f, args.sampleTime);
} else
{
}
else {
float light = 0.0f;
for(int c=0; c<out_channels; c++) {
for (int c = 0; c < out_channels; c++) {
float tmp = outputs[OUT1_OUTPUT].getVoltage(c);
light += tmp*tmp;
light += tmp * tmp;
}
light = sqrt(light);
light = std::sqrt(light);
lights[OUT_POS_LIGHT].setBrightness(0.0f);
lights[OUT_NEG_LIGHT].setBrightness(0.0f);
lights[OUT_BLUE_LIGHT].setSmoothBrightness(light / 5.f, args.sampleTime);
}
}
};




struct MixerWidget : ModuleWidget {
MixerWidget(Mixer *module) {
setModule(module);


+ 18
- 18
src/PulseGenerator_4.hpp View File

@@ -5,28 +5,28 @@

/** When triggered, holds a high value for a specified time before going low again */
struct PulseGenerator_4 {
simd::float_4 remaining = simd::float_4::zero();

/** Immediately disables the pulse */
void reset() {
remaining = simd::float_4::zero();
}
simd::float_4 remaining = simd::float_4::zero();

/** Advances the state by `deltaTime`. Returns whether the pulse is in the HIGH state. */
inline simd::float_4 process(float deltaTime) {
/** Immediately disables the pulse */
void reset() {
remaining = simd::float_4::zero();
}

simd::float_4 mask = (remaining > simd::float_4::zero());
/** Advances the state by `deltaTime`. Returns whether the pulse is in the HIGH state. */
inline simd::float_4 process(float deltaTime) {

remaining -= ifelse(mask, simd::float_4(deltaTime), simd::float_4::zero());
return ifelse(mask, simd::float_4::mask(), simd::float_4::zero());
}
simd::float_4 mask = (remaining > simd::float_4::zero());

/** Begins a trigger with the given `duration`. */
inline void trigger(simd::float_4 mask, float duration = 1e-3f) {
// Keep the previous pulse if the existing pulse will be held longer than the currently requested one.
simd::float_4 duration_4 = simd::float_4(duration);
remaining = ifelse( mask&(duration_4>remaining), duration_4, remaining);
}
remaining -= ifelse(mask, simd::float_4(deltaTime), simd::float_4::zero());
return ifelse(mask, simd::float_4::mask(), simd::float_4::zero());
}

/** Begins a trigger with the given `duration`. */
inline void trigger(simd::float_4 mask, float duration = 1e-3f) {
// Keep the previous pulse if the existing pulse will be held longer than the currently requested one.
simd::float_4 duration_4 = simd::float_4(duration);
remaining = ifelse(mask & (duration_4 > remaining), duration_4, remaining);
}
};


+ 110
- 103
src/Rampage.cpp View File

@@ -81,7 +81,7 @@ struct Rampage : Module {
dsp::TSchmittTrigger<simd::float_4> trigger_4[2][4];
PulseGenerator_4 endOfCyclePulse[2][4];

// ChannelMask channelMask;
// ChannelMask channelMask;

Rampage() {
config(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS);
@@ -99,29 +99,28 @@ struct Rampage : Module {
configParam(CYCLE_B_PARAM, 0.0, 1.0, 0.0, "Ch 2 cycle");
configParam(BALANCE_PARAM, 0.0, 1.0, 0.5, "Balance");

memset(out, 0, sizeof(out));
memset(gate, 0, sizeof(gate));
std::memset(out, 0, sizeof(out));
std::memset(gate, 0, sizeof(gate));
}

void process(const ProcessArgs &args) override {

int channels_in[2];
int channels_trig[2];
int channels[2];

// determine number of channels:
// determine number of channels:

for (int part = 0; part < 2; part++) {

for (int part=0; part<2; part++) {
channels_in[part] = inputs[IN_A_INPUT+part].getChannels();
channels_trig[part] = inputs[TRIGG_A_INPUT+part].getChannels();
channels_in[part] = inputs[IN_A_INPUT + part].getChannels();
channels_trig[part] = inputs[TRIGG_A_INPUT + part].getChannels();
channels[part] = std::max(channels_in[part], channels_trig[part]);
channels[part] = std::max(1, channels[part]);

outputs[OUT_A_OUTPUT+part].setChannels(channels[part]);
outputs[RISING_A_OUTPUT+part].setChannels(channels[part]);
outputs[FALLING_A_OUTPUT+part].setChannels(channels[part]);
outputs[EOC_A_OUTPUT+part].setChannels(channels[part]);
outputs[OUT_A_OUTPUT + part].setChannels(channels[part]);
outputs[RISING_A_OUTPUT + part].setChannels(channels[part]);
outputs[FALLING_A_OUTPUT + part].setChannels(channels[part]);
outputs[EOC_A_OUTPUT + part].setChannels(channels[part]);
}
int channels_max = std::max(channels[0], channels[1]);

@@ -145,9 +144,15 @@ struct Rampage : Module {
float shape = params[SHAPE_A_PARAM + part].getValue();
float minTime;
switch ((int) params[RANGE_A_PARAM + part].getValue()) {
case 0: minTime = 1e-2; break;
case 1: minTime = 1e-3; break;
default: minTime = 1e-1; break;
case 0:
minTime = 1e-2;
break;
case 1:
minTime = 1e-3;
break;
default:
minTime = 1e-1;
break;
}

simd::float_4 param_rise = simd::float_4(params[RISE_A_PARAM + part].getValue() * 10.0f);
@@ -155,115 +160,117 @@ struct Rampage : Module {
simd::float_4 param_trig = simd::float_4(params[TRIGG_A_PARAM + part].getValue() * 20.0f);
simd::float_4 param_cycle = simd::float_4(params[CYCLE_A_PARAM + part].getValue() * 10.0f);

for(int c=0; c<channels[part]; c+=4) {
riseCV[c/4] = param_rise;
fallCV[c/4] = param_fall;
cycle[c/4] = param_cycle;
in_trig[c/4] = param_trig;
for (int c = 0; c < channels[part]; c += 4) {
riseCV[c / 4] = param_rise;
fallCV[c / 4] = param_fall;
cycle[c / 4] = param_cycle;
in_trig[c / 4] = param_trig;

}


// read inputs:

if(inputs[IN_A_INPUT + part].isConnected()) {
if (inputs[IN_A_INPUT + part].isConnected()) {
load_input(inputs[IN_A_INPUT + part], in, channels_in[part]);
// channelMask.apply_all(in, channels_in[part]);
} else {
memset(in, 0, sizeof(in));
}
else {
std::memset(in, 0, sizeof(in));
}

if(inputs[TRIGG_A_INPUT + part].isConnected()) {
if (inputs[TRIGG_A_INPUT + part].isConnected()) {
add_input(inputs[TRIGG_A_INPUT + part], in_trig, channels_trig[part]);
// channelMask.apply_all(in_trig, channels_trig[part]);
}
}

if(inputs[EXP_CV_A_INPUT + part].isConnected()) {
if (inputs[EXP_CV_A_INPUT + part].isConnected()) {
load_input(inputs[EXP_CV_A_INPUT + part], expCV, channels[part]);
for(int c=0; c<channels[part]; c+=4) {
riseCV[c/4] -= expCV[c/4];
fallCV[c/4] -= expCV[c/4];
for (int c = 0; c < channels[part]; c += 4) {
riseCV[c / 4] -= expCV[c / 4];
fallCV[c / 4] -= expCV[c / 4];
}
}

add_input(inputs[RISE_CV_A_INPUT + part], riseCV, channels[part]);
add_input(inputs[FALL_CV_A_INPUT + part], fallCV, channels[part]);
add_input(inputs[CYCLE_A_INPUT+part], cycle, channels[part]);
add_input(inputs[FALL_CV_A_INPUT + part], fallCV, channels[part]);
add_input(inputs[CYCLE_A_INPUT + part], cycle, channels[part]);
// channelMask.apply(cycle, channels[part]); // check whether this is necessary

// start processing:
for(int c=0; c<channels[part]; c+=4) {
for (int c = 0; c < channels[part]; c += 4) {

// process SchmittTriggers

simd::float_4 trig_mask = trigger_4[part][c/4].process(in_trig[c/4]/2.0);
gate[part][c/4] = ifelse(trig_mask, simd::float_4::mask(), gate[part][c/4]);
in[c/4] = ifelse(gate[part][c/4], simd::float_4(10.0f), in[c/4]);
simd::float_4 trig_mask = trigger_4[part][c / 4].process(in_trig[c / 4] / 2.0);
gate[part][c / 4] = ifelse(trig_mask, simd::float_4::mask(), gate[part][c / 4]);
in[c / 4] = ifelse(gate[part][c / 4], simd::float_4(10.0f), in[c / 4]);

simd::float_4 delta = in[c/4] - out[part][c/4];
simd::float_4 delta = in[c / 4] - out[part][c / 4];

// rise / fall branching

simd::float_4 delta_gt_0 = delta > simd::float_4::zero();
simd::float_4 delta_lt_0 = delta < simd::float_4::zero();
simd::float_4 delta_eq_0 = ~(delta_lt_0|delta_gt_0);
simd::float_4 delta_eq_0 = ~(delta_lt_0 | delta_gt_0);

simd::float_4 rateCV = ifelse(delta_gt_0, riseCV[c/4], simd::float_4::zero());
rateCV = ifelse(delta_lt_0, fallCV[c/4], rateCV);
simd::float_4 rateCV = ifelse(delta_gt_0, riseCV[c / 4], simd::float_4::zero());
rateCV = ifelse(delta_lt_0, fallCV[c / 4], rateCV);
rateCV = clamp(rateCV, simd::float_4::zero(), simd::float_4(10.0f));

simd::float_4 rate = minTime * simd::pow(2.0f, rateCV);

out[part][c/4] += shapeDelta(delta, rate, shape) * args.sampleTime;
out[part][c / 4] += shapeDelta(delta, rate, shape) * args.sampleTime;

simd::float_4 rising = (in[c/4] - out[part][c/4]) > simd::float_4( 1e-3);
simd::float_4 falling = (in[c/4] - out[part][c/4]) < simd::float_4(-1e-3);
simd::float_4 end_of_cycle = simd::andnot(falling,delta_lt_0);
simd::float_4 rising = (in[c / 4] - out[part][c / 4]) > simd::float_4(1e-3);
simd::float_4 falling = (in[c / 4] - out[part][c / 4]) < simd::float_4(-1e-3);
simd::float_4 end_of_cycle = simd::andnot(falling, delta_lt_0);

endOfCyclePulse[part][c/4].trigger(end_of_cycle, 1e-3);
endOfCyclePulse[part][c / 4].trigger(end_of_cycle, 1e-3);

gate[part][c/4] = ifelse( simd::andnot(rising, delta_gt_0), simd::float_4::zero(), gate[part][c/4]);
gate[part][c/4] = ifelse( end_of_cycle & (cycle[c/4]>=simd::float_4(4.0f)), simd::float_4::mask(), gate[part][c/4] );
gate[part][c/4] = ifelse( delta_eq_0, simd::float_4::zero(), gate[part][c/4] );
gate[part][c / 4] = ifelse(simd::andnot(rising, delta_gt_0), simd::float_4::zero(), gate[part][c / 4]);
gate[part][c / 4] = ifelse(end_of_cycle & (cycle[c / 4] >= simd::float_4(4.0f)), simd::float_4::mask(), gate[part][c / 4]);
gate[part][c / 4] = ifelse(delta_eq_0, simd::float_4::zero(), gate[part][c / 4]);

out[part][c/4] = ifelse( rising|falling, out[part][c/4], in[c/4] );
out[part][c / 4] = ifelse(rising | falling, out[part][c / 4], in[c / 4]);

simd::float_4 out_rising = ifelse(rising, simd::float_4(10.0f), simd::float_4::zero() );
simd::float_4 out_falling = ifelse(falling, simd::float_4(10.0f), simd::float_4::zero() );
simd::float_4 out_rising = ifelse(rising, simd::float_4(10.0f), simd::float_4::zero());
simd::float_4 out_falling = ifelse(falling, simd::float_4(10.0f), simd::float_4::zero());

simd::float_4 pulse = endOfCyclePulse[part][c/4].process(args.sampleTime);
simd::float_4 out_EOC = ifelse(pulse, simd::float_4(10.f), simd::float_4::zero() );
simd::float_4 pulse = endOfCyclePulse[part][c / 4].process(args.sampleTime);
simd::float_4 out_EOC = ifelse(pulse, simd::float_4(10.f), simd::float_4::zero());

out[part][c/4].store(outputs[OUT_A_OUTPUT+part].getVoltages(c));
out[part][c / 4].store(outputs[OUT_A_OUTPUT + part].getVoltages(c));

out_rising.store( outputs[RISING_A_OUTPUT+part].getVoltages(c));
out_falling.store(outputs[FALLING_A_OUTPUT+part].getVoltages(c));
out_EOC.store(outputs[EOC_A_OUTPUT+part].getVoltages(c));
out_rising.store(outputs[RISING_A_OUTPUT + part].getVoltages(c));
out_falling.store(outputs[FALLING_A_OUTPUT + part].getVoltages(c));
out_EOC.store(outputs[EOC_A_OUTPUT + part].getVoltages(c));


} // for(int c, ...)

if(channels[part] == 1) {
lights[RISING_A_LIGHT + 3*part ].setSmoothBrightness(outputs[RISING_A_OUTPUT+part].getVoltage()/10.f, args.sampleTime);
lights[RISING_A_LIGHT + 3*part+1].setBrightness(0.0f);
lights[RISING_A_LIGHT + 3*part+2].setBrightness(0.0f);
lights[FALLING_A_LIGHT + 3*part ].setSmoothBrightness(outputs[FALLING_A_OUTPUT+part].getVoltage()/10.f, args.sampleTime);
lights[FALLING_A_LIGHT + 3*part+1].setBrightness(0.0f);
lights[FALLING_A_LIGHT + 3*part+2].setBrightness(0.0f);
lights[OUT_A_LIGHT + 3*part ].setSmoothBrightness(out[part][0].s[0] / 10.0, args.sampleTime);
lights[OUT_A_LIGHT + 3*part+1].setBrightness(0.0f);
lights[OUT_A_LIGHT + 3*part+2].setBrightness(0.0f);
} else {
lights[RISING_A_LIGHT + 3*part ].setBrightness(0.0f);
lights[RISING_A_LIGHT + 3*part+1].setBrightness(0.0f);
lights[RISING_A_LIGHT + 3*part+2].setBrightness(10.0f);
lights[FALLING_A_LIGHT + 3*part ].setBrightness(0.0f);
lights[FALLING_A_LIGHT + 3*part+1].setBrightness(0.0f);
lights[FALLING_A_LIGHT + 3*part+2].setBrightness(10.0f);
lights[OUT_A_LIGHT + 3*part ].setBrightness(0.0f);
lights[OUT_A_LIGHT + 3*part+1].setBrightness(0.0f);
lights[OUT_A_LIGHT + 3*part+2].setBrightness(10.0f);
if (channels[part] == 1) {
lights[RISING_A_LIGHT + 3 * part ].setSmoothBrightness(outputs[RISING_A_OUTPUT + part].getVoltage() / 10.f, args.sampleTime);
lights[RISING_A_LIGHT + 3 * part + 1].setBrightness(0.0f);
lights[RISING_A_LIGHT + 3 * part + 2].setBrightness(0.0f);
lights[FALLING_A_LIGHT + 3 * part ].setSmoothBrightness(outputs[FALLING_A_OUTPUT + part].getVoltage() / 10.f, args.sampleTime);
lights[FALLING_A_LIGHT + 3 * part + 1].setBrightness(0.0f);
lights[FALLING_A_LIGHT + 3 * part + 2].setBrightness(0.0f);
lights[OUT_A_LIGHT + 3 * part ].setSmoothBrightness(out[part][0].s[0] / 10.0, args.sampleTime);
lights[OUT_A_LIGHT + 3 * part + 1].setBrightness(0.0f);
lights[OUT_A_LIGHT + 3 * part + 2].setBrightness(0.0f);
}
else {
lights[RISING_A_LIGHT + 3 * part ].setBrightness(0.0f);
lights[RISING_A_LIGHT + 3 * part + 1].setBrightness(0.0f);
lights[RISING_A_LIGHT + 3 * part + 2].setBrightness(10.0f);
lights[FALLING_A_LIGHT + 3 * part ].setBrightness(0.0f);
lights[FALLING_A_LIGHT + 3 * part + 1].setBrightness(0.0f);
lights[FALLING_A_LIGHT + 3 * part + 2].setBrightness(10.0f);
lights[OUT_A_LIGHT + 3 * part ].setBrightness(0.0f);
lights[OUT_A_LIGHT + 3 * part + 1].setBrightness(0.0f);
lights[OUT_A_LIGHT + 3 * part + 2].setBrightness(10.0f);
}

} // for (int part, ... )
@@ -272,19 +279,19 @@ struct Rampage : Module {
// Logic
float balance = params[BALANCE_PARAM].getValue();

for(int c=0; c<channels_max; c+=4) {
for (int c = 0; c < channels_max; c += 4) {

simd::float_4 a = out[0][c/4];
simd::float_4 b = out[1][c/4];
simd::float_4 a = out[0][c / 4];
simd::float_4 b = out[1][c / 4];

if (balance < 0.5)
b *= 2.0f * balance;
else if (balance > 0.5)
a *= 2.0f * (1.0 - balance);

simd::float_4 comp = ifelse( b>a, simd::float_4(10.0f), simd::float_4::zero() );
simd::float_4 out_min = simd::fmin(a,b);
simd::float_4 out_max = simd::fmax(a,b);
simd::float_4 comp = ifelse(b > a, simd::float_4(10.0f), simd::float_4::zero());
simd::float_4 out_min = simd::fmin(a, b);
simd::float_4 out_max = simd::fmax(a, b);

comp.store(outputs[COMPARATOR_OUTPUT].getVoltages(c));
out_min.store(outputs[MIN_OUTPUT].getVoltages(c));
@@ -292,29 +299,29 @@ struct Rampage : Module {

}
// Lights
if(channels_max==1) {
if (channels_max == 1) {
lights[COMPARATOR_LIGHT ].setSmoothBrightness(outputs[COMPARATOR_OUTPUT].getVoltage(), args.sampleTime);
lights[COMPARATOR_LIGHT+1].setBrightness(0.0f);
lights[COMPARATOR_LIGHT+2].setBrightness(0.0f);
lights[COMPARATOR_LIGHT + 1].setBrightness(0.0f);
lights[COMPARATOR_LIGHT + 2].setBrightness(0.0f);
lights[MIN_LIGHT ].setSmoothBrightness(outputs[MIN_OUTPUT].getVoltage(), args.sampleTime);
lights[MIN_LIGHT+1].setBrightness(0.0f);
lights[MIN_LIGHT+2].setBrightness(0.0f);
lights[MIN_LIGHT + 1].setBrightness(0.0f);
lights[MIN_LIGHT + 2].setBrightness(0.0f);
lights[MAX_LIGHT ].setSmoothBrightness(outputs[MAX_OUTPUT].getVoltage(), args.sampleTime);
lights[MAX_LIGHT+1].setBrightness(0.0f);
lights[MAX_LIGHT+2].setBrightness(0.0f);
} else {
lights[MAX_LIGHT + 1].setBrightness(0.0f);
lights[MAX_LIGHT + 2].setBrightness(0.0f);
}
else {
lights[COMPARATOR_LIGHT ].setBrightness(0.0f);
lights[COMPARATOR_LIGHT+1].setBrightness(0.0f);
lights[COMPARATOR_LIGHT+2].setBrightness(10.0f);
lights[COMPARATOR_LIGHT + 1].setBrightness(0.0f);
lights[COMPARATOR_LIGHT + 2].setBrightness(10.0f);
lights[MIN_LIGHT ].setBrightness(0.0f);
lights[MIN_LIGHT+1].setBrightness(0.0f);
lights[MIN_LIGHT+2].setBrightness(10.0f);
lights[MIN_LIGHT + 1].setBrightness(0.0f);
lights[MIN_LIGHT + 2].setBrightness(10.0f);
lights[MAX_LIGHT ].setBrightness(0.0f);
lights[MAX_LIGHT+1].setBrightness(0.0f);
lights[MAX_LIGHT+2].setBrightness(10.0f);
lights[MAX_LIGHT + 1].setBrightness(0.0f);
lights[MAX_LIGHT + 2].setBrightness(10.0f);
}

} // end process()
}
};


@@ -326,9 +333,9 @@ struct RampageWidget : ModuleWidget {
setPanel(APP->window->loadSvg(asset::plugin(pluginInstance, "res/Rampage.svg")));

addChild(createWidget<Knurlie>(Vec(15, 0)));
addChild(createWidget<Knurlie>(Vec(box.size.x-30, 0)));
addChild(createWidget<Knurlie>(Vec(box.size.x - 30, 0)));
addChild(createWidget<Knurlie>(Vec(15, 365)));
addChild(createWidget<Knurlie>(Vec(box.size.x-30, 365)));
addChild(createWidget<Knurlie>(Vec(box.size.x - 30, 365)));

addParam(createParam<BefacoSwitch>(Vec(94, 32), module, Rampage::RANGE_A_PARAM));
addParam(createParam<BefacoTinyKnob>(Vec(27, 90), module, Rampage::SHAPE_A_PARAM));
@@ -350,7 +357,7 @@ struct RampageWidget : ModuleWidget {
addInput(createInput<PJ301MPort>(Vec(67, 268), module, Rampage::FALL_CV_A_INPUT));
addInput(createInput<PJ301MPort>(Vec(38, 297), module, Rampage::EXP_CV_A_INPUT));
addInput(createInput<PJ301MPort>(Vec(102, 290), module, Rampage::CYCLE_A_INPUT));
addInput(createInput<PJ301MPort>(Vec(229, 30), module, Rampage::IN_B_INPUT));
addInput(createInput<PJ301MPort>(Vec(229, 30), module, Rampage::IN_B_INPUT));
addInput(createInput<PJ301MPort>(Vec(192, 37), module, Rampage::TRIGG_B_INPUT));
addInput(createInput<PJ301MPort>(Vec(176, 268), module, Rampage::RISE_CV_B_INPUT));
addInput(createInput<PJ301MPort>(Vec(237, 268), module, Rampage::FALL_CV_B_INPUT));


+ 14
- 15
src/SlewLimiter.cpp View File

@@ -44,41 +44,40 @@ struct SlewLimiter : Module {
const float slewMin = 0.1;
const float slewMax = 10000.f;
// Amount of extra slew per voltage difference
const float shapeScale = 1/10.f;
const float shapeScale = 1 / 10.f;

const simd::float_4 shape = simd::float_4(params[SHAPE_PARAM].getValue());
const simd::float_4 param_rise = simd::float_4(params[RISE_PARAM].getValue() * 10.f);
const simd::float_4 param_fall = simd::float_4(params[FALL_PARAM].getValue() * 10.f);


outputs[OUT_OUTPUT].setChannels(channels);

load_input(inputs[IN_INPUT], in, channels);
load_input(inputs[RISE_INPUT], riseCV, channels);
load_input(inputs[FALL_INPUT], fallCV, channels);
load_input(inputs[IN_INPUT], in, channels);
load_input(inputs[RISE_INPUT], riseCV, channels);
load_input(inputs[FALL_INPUT], fallCV, channels);

for(int c=0; c<channels; c+=4) {
riseCV[c/4] += param_rise;
fallCV[c/4] += param_fall;
for (int c = 0; c < channels; c += 4) {
riseCV[c / 4] += param_rise;
fallCV[c / 4] += param_fall;

simd::float_4 delta = in[c/4] - out[c/4];
simd::float_4 delta = in[c / 4] - out[c / 4];

simd::float_4 delta_gt_0 = delta > simd::float_4::zero();
simd::float_4 delta_lt_0 = delta < simd::float_4::zero();

simd::float_4 rateCV;
rateCV = ifelse(delta_gt_0, riseCV[c/4], simd::float_4::zero());
rateCV = ifelse(delta_lt_0, fallCV[c/4], rateCV) * 0.1f;
rateCV = ifelse(delta_gt_0, riseCV[c / 4], simd::float_4::zero());
rateCV = ifelse(delta_lt_0, fallCV[c / 4], rateCV) * 0.1f;

simd::float_4 pm_one = simd::sgn(delta);

simd::float_4 slew = slewMax * simd::pow(simd::float_4(slewMin / slewMax), rateCV);

out[c/4] += slew * simd::crossfade(pm_one, shapeScale*delta, shape) * args.sampleTime;
out[c/4] = ifelse( delta_gt_0 & (out[c/4]>in[c/4]), in[c/4], out[c/4]);
out[c/4] = ifelse( delta_lt_0 & (out[c/4]<in[c/4]), in[c/4], out[c/4]);
out[c / 4] += slew * simd::crossfade(pm_one, shapeScale * delta, shape) * args.sampleTime;
out[c / 4] = ifelse(delta_gt_0 & (out[c / 4] > in[c / 4]), in[c / 4], out[c / 4]);
out[c / 4] = ifelse(delta_lt_0 & (out[c / 4] < in[c / 4]), in[c / 4], out[c / 4]);

out[c/4].store(outputs[OUT_OUTPUT].getVoltages(c));
out[c / 4].store(outputs[OUT_OUTPUT].getVoltages(c));
}
}
};


+ 18
- 18
src/SpringReverb.cpp View File

@@ -32,15 +32,15 @@ struct SpringReverb : Module {
};
enum LightIds {
PEAK_LIGHT,
VU1_LIGHT,
NUM_LIGHTS = VU1_LIGHT + 7
ENUMS(VU1_LIGHTS, 7),
NUM_LIGHTS
};

dsp::RealTimeConvolver *convolver = NULL;
dsp::SampleRateConverter<1> inputSrc;
dsp::SampleRateConverter<1> outputSrc;
dsp::DoubleRingBuffer<dsp::Frame<1>, 16*BLOCK_SIZE> inputBuffer;
dsp::DoubleRingBuffer<dsp::Frame<1>, 16*BLOCK_SIZE> outputBuffer;
dsp::DoubleRingBuffer<dsp::Frame<1>, 16 * BLOCK_SIZE> inputBuffer;
dsp::DoubleRingBuffer<dsp::Frame<1>, 16 * BLOCK_SIZE> outputBuffer;

dsp::RCFilter dryFilter;
dsp::PeakFilter vuFilter;
@@ -55,7 +55,7 @@ struct SpringReverb : Module {

convolver = new dsp::RealTimeConvolver(BLOCK_SIZE);

const float *kernel = (const float*) BINARY_START(src_SpringReverbIR_pcm);
const float *kernel = (const float *) BINARY_START(src_SpringReverbIR_pcm);
size_t kernelLen = BINARY_SIZE(src_SpringReverbIR_pcm) / sizeof(float);
convolver->setKernel(kernel, kernelLen);
}
@@ -94,7 +94,7 @@ struct SpringReverb : Module {
inputSrc.setRates(args.sampleRate, 48000);
int inLen = inputBuffer.size();
int outLen = BLOCK_SIZE;
inputSrc.process(inputBuffer.startData(), &inLen, (dsp::Frame<1>*) input, &outLen);
inputSrc.process(inputBuffer.startData(), &inLen, (dsp::Frame<1> *) input, &outLen);
inputBuffer.startIncr(inLen);
}

@@ -106,7 +106,7 @@ struct SpringReverb : Module {
outputSrc.setRates(48000, args.sampleRate);
int inLen = BLOCK_SIZE;
int outLen = outputBuffer.capacity();
outputSrc.process((dsp::Frame<1>*) output, &inLen, outputBuffer.endData(), &outLen);
outputSrc.process((dsp::Frame<1> *) output, &inLen, outputBuffer.endData(), &outLen);
outputBuffer.endIncr(outLen);
}
}
@@ -126,12 +126,12 @@ struct SpringReverb : Module {
vuFilter.setRate(lightRate);
vuFilter.process(std::fabs(wet));
lightFilter.setRate(lightRate);
lightFilter.process(std::fabs(dry*50.0));
lightFilter.process(std::fabs(dry * 50.0));

float vuValue = vuFilter.peak();
for (int i = 0; i < 7; i++) {
float light = std::pow(1.413, i) * vuValue / 10.0 - 1.0;
lights[VU1_LIGHT + i].value = clamp(light, 0.0f, 1.0f);
lights[VU1_LIGHTS + i].value = clamp(light, 0.0f, 1.0f);
}
lights[PEAK_LIGHT].value = lightFilter.peak();
}
@@ -145,8 +145,8 @@ struct SpringReverbWidget : ModuleWidget {

addChild(createWidget<Knurlie>(Vec(15, 0)));
addChild(createWidget<Knurlie>(Vec(15, 365)));
addChild(createWidget<Knurlie>(Vec(15*6, 0)));
addChild(createWidget<Knurlie>(Vec(15*6, 365)));
addChild(createWidget<Knurlie>(Vec(15 * 6, 0)));
addChild(createWidget<Knurlie>(Vec(15 * 6, 365)));

addParam(createParam<BefacoBigKnob>(Vec(22, 29), module, SpringReverb::WET_PARAM));

@@ -165,13 +165,13 @@ struct SpringReverbWidget : ModuleWidget {
addOutput(createOutput<PJ301MPort>(Vec(88, 317), module, SpringReverb::WET_OUTPUT));

addChild(createLight<MediumLight<GreenRedLight>>(Vec(55, 269), module, SpringReverb::PEAK_LIGHT));
addChild(createLight<MediumLight<RedLight>>(Vec(55, 113), module, SpringReverb::VU1_LIGHT + 0));
addChild(createLight<MediumLight<YellowLight>>(Vec(55, 126), module, SpringReverb::VU1_LIGHT + 1));
addChild(createLight<MediumLight<YellowLight>>(Vec(55, 138), module, SpringReverb::VU1_LIGHT + 2));
addChild(createLight<MediumLight<GreenLight>>(Vec(55, 150), module, SpringReverb::VU1_LIGHT + 3));
addChild(createLight<MediumLight<GreenLight>>(Vec(55, 163), module, SpringReverb::VU1_LIGHT + 4));
addChild(createLight<MediumLight<GreenLight>>(Vec(55, 175), module, SpringReverb::VU1_LIGHT + 5));
addChild(createLight<MediumLight<GreenLight>>(Vec(55, 188), module, SpringReverb::VU1_LIGHT + 6));
addChild(createLight<MediumLight<RedLight>>(Vec(55, 113), module, SpringReverb::VU1_LIGHTS + 0));
addChild(createLight<MediumLight<YellowLight>>(Vec(55, 126), module, SpringReverb::VU1_LIGHTS + 1));
addChild(createLight<MediumLight<YellowLight>>(Vec(55, 138), module, SpringReverb::VU1_LIGHTS + 2));
addChild(createLight<MediumLight<GreenLight>>(Vec(55, 150), module, SpringReverb::VU1_LIGHTS + 3));
addChild(createLight<MediumLight<GreenLight>>(Vec(55, 163), module, SpringReverb::VU1_LIGHTS + 4));
addChild(createLight<MediumLight<GreenLight>>(Vec(55, 175), module, SpringReverb::VU1_LIGHTS + 5));
addChild(createLight<MediumLight<GreenLight>>(Vec(55, 188), module, SpringReverb::VU1_LIGHTS + 6));
}
};



+ 14
- 10
src/simd_input.hpp View File

@@ -3,22 +3,26 @@
#include "rack.hpp"



inline void load_input(Input &in, simd::float_4 *v, int numChannels) {
int inChannels = in.getChannels();
if(inChannels==1) {
for(int i=0; i<numChannels; i++) v[i] = simd::float_4(in.getVoltage());
} else {
for(int c=0; c<inChannels; c+=4) v[c/4] = simd::float_4::load(in.getVoltages(c));
if (inChannels == 1) {
for (int i = 0; i < numChannels; i++)
v[i] = simd::float_4(in.getVoltage());
}
else {
for (int c = 0; c < inChannels; c += 4)
v[c / 4] = simd::float_4::load(in.getVoltages(c));
}
}

inline void add_input(Input &in, simd::float_4 *v, int numChannels) {
int inChannels = in.getChannels();
if(inChannels==1) {
for(int i=0; i<numChannels; i++) v[i] += simd::float_4(in.getVoltage());
} else {
for(int c=0; c<inChannels; c+=4) v[c/4] += simd::float_4::load(in.getVoltages(c));
if (inChannels == 1) {
for (int i = 0; i < numChannels; i++)
v[i] += simd::float_4(in.getVoltage());
}
else {
for (int c = 0; c < inChannels; c += 4)
v[c / 4] += simd::float_4::load(in.getVoltages(c));
}
}


Write Preview
Loading…
Cancel
Save