BogaudioModules

BogaudioModules for VCV Rack
Log | Files | Refs | README | LICENSE

Test.cpp (19421B)


      1 
      2 #include "Test.hpp"
      3 
      4 void Test::reset() {
      5 }
      6 
      7 void Test::processAll(const ProcessArgs& args) {
      8 	if (!(outputs[OUT_OUTPUT].isConnected() || outputs[OUT2_OUTPUT].isConnected())) {
      9 		return;
     10 	}
     11 
     12 #ifdef LPF
     13 	if (!inputs[IN_INPUT].isConnected()) {
     14 		return;
     15 	}
     16 	float sr = APP->engine->getSampleRate();
     17 	_lpf.setParams(
     18 		sr,
     19 		0.49f * sr * clamp(params[PARAM1_PARAM].getValue(), 0.0f, 1.0f),
     20 		std::max(10.0 * clamp(params[PARAM2_PARAM].getValue(), 0.0f, 1.0f), 0.1)
     21 	);
     22 	outputs[OUT_OUTPUT].setVoltage(_lpf.next(inputs[IN_INPUT].getVoltage()));
     23 
     24 #elif LPFNOISE
     25 	_lpf.setParams(
     26 		APP->engine->getSampleRate(),
     27 		22000.0 * clamp(params[PARAM1_PARAM].getValue(), 0.0f, 1.0f),
     28 		0.717f
     29 	);
     30 	float noise = _noise.next();
     31 	outputs[OUT_OUTPUT].setVoltage(_lpf.next(noise) * 10.0);;
     32 	outputs[OUT2_OUTPUT].setVoltage(noise * 10.0);;
     33 
     34 #elif SINE
     35 	_sine.setSampleRate(APP->engine->getSampleRate());
     36 	_sine.setFrequency(oscillatorPitch());
     37 	outputs[OUT_OUTPUT].setVoltage(_sine.next() * 5.0f);
     38 
     39 	_sine2.setSampleRate(APP->engine->getSampleRate());
     40 	_sine2.setFrequency(oscillatorPitch());
     41 	outputs[OUT2_OUTPUT].setVoltage(_sine2.next() * 5.0f);
     42 
     43 #elif SQUARE
     44 	_square.setSampleRate(APP->engine->getSampleRate());
     45 	_square.setFrequency(oscillatorPitch());
     46 	float pw = params[PARAM2_PARAM].getValue();
     47 	if (inputs[CV2_INPUT].isConnected()) {
     48 		pw += clamp(inputs[CV2_INPUT].getVoltage(), -5.0f, 5.0f) / 10.0f;
     49 	}
     50 	_square.setPulseWidth(pw);
     51 	outputs[OUT_OUTPUT].setVoltage(_square.next() * 5.0f);
     52 
     53 	_square2.setSampleRate(APP->engine->getSampleRate());
     54 	_square2.setFrequency(oscillatorPitch());
     55 	_square2.setPulseWidth(pw);
     56 	_square2.setQuality(params[PARAM3_PARAM].getValue() * 200);
     57 	outputs[OUT2_OUTPUT].setVoltage(_square2.next() * 5.0f);
     58 
     59 #elif SAW
     60 	_saw.setSampleRate(APP->engine->getSampleRate());
     61 	_saw.setFrequency(oscillatorPitch());
     62 	outputs[OUT_OUTPUT].setVoltage(_saw.next() * 5.0f);
     63 
     64 	_saw2.setSampleRate(APP->engine->getSampleRate());
     65 	_saw2.setFrequency(oscillatorPitch());
     66 	_saw2.setQuality(params[PARAM2_PARAM].getValue() * 200);
     67 	outputs[OUT2_OUTPUT].setVoltage(_saw2.next() * 5.0f);
     68 
     69 #elif SATSAW
     70 	float saturation = params[PARAM2_PARAM].getValue() * 10.0f;
     71 	if (inputs[CV2_INPUT].isConnected()) {
     72 		saturation *= clamp(inputs[CV2_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
     73 	}
     74 	_saw.setSampleRate(APP->engine->getSampleRate());
     75 	_saw.setFrequency(oscillatorPitch());
     76 	_saw.setSaturation(saturation);
     77 	outputs[OUT_OUTPUT].setVoltage(_saw.next() * 5.0f);
     78 
     79 	_saw2.setSampleRate(APP->engine->getSampleRate());
     80 	_saw2.setFrequency(oscillatorPitch());
     81 	_saw2.setSaturation(saturation);
     82 	_saw2.setQuality(params[PARAM3_PARAM].getValue() * 200);
     83 	outputs[OUT2_OUTPUT].setVoltage(_saw2.next() * 5.0f);
     84 
     85 #elif TRIANGLE
     86 	_triangle.setSampleRate(APP->engine->getSampleRate());
     87 	_triangle.setFrequency(oscillatorPitch());
     88 	outputs[OUT_OUTPUT].setVoltage(_triangle.next() * 5.0f);
     89 
     90 #elif SAMPLED_TRIANGLE
     91 	float sample = params[PARAM2_PARAM].getValue() * Phasor::maxSampleWidth;
     92 	if (inputs[CV2_INPUT].isConnected()) {
     93 		sample *= clamp(inputs[CV2_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f);
     94 	}
     95 	_triangle.setSampleRate(APP->engine->getSampleRate());
     96 	_triangle.setFrequency(oscillatorPitch());
     97 	_triangle.setSampleWidth(sample);
     98 	outputs[OUT_OUTPUT].setVoltage(_triangle.next() * 5.0f);
     99 
    100 	_triangle2.setSampleRate(APP->engine->getSampleRate());
    101 	_triangle2.setFrequency(oscillatorPitch());
    102 	float maxSampleSteps = (_triangle2._sampleRate / _triangle2._frequency) / 4.0f;
    103 	_sampleSteps = clamp((int)((4.0f * sample) * maxSampleSteps), 1, (int)maxSampleSteps);
    104 	++_sampleStep;
    105 	if (_sampleStep >= _sampleSteps) {
    106 		_sampleStep = 0;
    107 		_sample = _triangle2.next() * 5.0f;
    108 	}
    109 	else {
    110 		_triangle2.advancePhase();
    111 	}
    112 	outputs[OUT2_OUTPUT].setVoltage(_sample);
    113 
    114 #elif SINEBANK
    115 	_sineBank.setSampleRate(APP->engine->getSampleRate());
    116 	_sineBank.setFrequency(oscillatorPitch());
    117 	outputs[OUT_OUTPUT].setVoltage(_sineBank.next());
    118 
    119 #elif OVERSAMPLING
    120 	_saw1.setSampleRate(APP->engine->getSampleRate());
    121 	_saw1.setFrequency(oscillatorPitch() / (float)OVERSAMPLEN);
    122 	float buf[OVERSAMPLEN];
    123 	for (int i = 0; i < OVERSAMPLEN; ++i) {
    124 		buf[i] = _saw1.next();
    125 	}
    126 	outputs[OUT_OUTPUT].setVoltage(_rackDecimator.process(buf) * 5.0f);
    127 
    128 	_saw2.setSampleRate(APP->engine->getSampleRate());
    129 	_saw2.setFrequency(oscillatorPitch() / (float)OVERSAMPLEN);
    130 	_lpf.setParams(
    131 		APP->engine->getSampleRate(),
    132 		APP->engine->getSampleRate() / 4.0f,
    133 		0.03
    134 	);
    135 	_lpf2.setParams(
    136 		APP->engine->getSampleRate(),
    137 		APP->engine->getSampleRate() / 4.0f,
    138 		0.03
    139 	);
    140 	float s = 0.0f;
    141 	for (int i = 0; i < OVERSAMPLEN; ++i) {
    142 		// s = _lpf2.next(_lpf.next(_saw2.next()));
    143 		s = _lpf.next(_saw2.next());
    144 		// s = _saw2.next();
    145 	}
    146 	outputs[OUT2_OUTPUT].setVoltage(s * 5.0);
    147 
    148 #elif OVERSAMPLED_BL
    149 	int quality = params[PARAM2_PARAM].getValue() * 100;
    150 	const int maxOversample = 16;
    151 	int oversample = params[PARAM3_PARAM].getValue() * maxOversample;
    152 
    153 	_saw1.setSampleRate(APP->engine->getSampleRate());
    154 	_saw1.setFrequency(oscillatorPitch());
    155 	_saw1.setQuality(quality);
    156 	outputs[OUT_OUTPUT].setVoltage(_saw1.next() * 5.0f);
    157 
    158 	_saw2.setSampleRate(APP->engine->getSampleRate());
    159 	_saw2.setQuality(quality);
    160 	if (oversample < 2) {
    161 		_saw2.setFrequency(oscillatorPitch());
    162 		outputs[OUT2_OUTPUT].setVoltage(_saw2.next() * 5.0f);
    163 	}
    164 	else {
    165 		_saw2.setFrequency(oscillatorPitch() / (float)oversample);
    166 		_lpf.setParams(
    167 			oversample * APP->engine->getSampleRate(),
    168 			0.95f * APP->engine->getSampleRate(),
    169 			0.03
    170 		);
    171 		float s = 0.0f;
    172 		for (int i = 0; i < oversample; ++i) {
    173 			s = _lpf.next(_saw2.next());
    174 		}
    175 		outputs[OUT2_OUTPUT].setVoltage(s * 5.0f);
    176 	}
    177 
    178 #elif ANTIALIASING
    179 	const int quality = 12;
    180 	const float oversampleThreshold = 0.06f;
    181 	const float oversampleMixWidth = 100.0f;
    182 	float sampleRate = APP->engine->getSampleRate();
    183 	float frequency = oscillatorPitch(15000.0);
    184 
    185 	float otf = oversampleThreshold * sampleRate;
    186 	float mix, oMix;
    187 	if (frequency > otf) {
    188 		if (frequency > otf + oversampleMixWidth) {
    189 			mix = 0.0f;
    190 			oMix = 1.0f;
    191 		}
    192 		else {
    193 			oMix = (frequency - otf) / oversampleMixWidth;
    194 			mix = 1.0f - oMix;
    195 		}
    196 	}
    197 	else {
    198 		mix = 1.0f;
    199 		oMix = 0.0f;
    200 	}
    201 	assert(mix >= 0.0f);
    202 	assert(mix <= 1.0f);
    203 	assert(oMix >= 0.0f);
    204 	assert(oMix <= 1.0f);
    205 
    206 	_phasor.setSampleRate(sampleRate);
    207 	_phasor.setFrequency(frequency);
    208 	_oversampledPhasor.setSampleRate(sampleRate);
    209 	_oversampledPhasor.setFrequency(frequency / (float)OVERSAMPLEN);
    210 	_saw.setSampleRate(sampleRate);
    211 	_saw.setQuality(quality);
    212 	_sawDecimator.setParams(sampleRate, OVERSAMPLEN);
    213 	_square.setSampleRate(sampleRate);
    214 	_square.setQuality(quality);
    215 	_squareDecimator.setParams(sampleRate, OVERSAMPLEN);
    216 
    217 	float out = 0.0f;
    218 	float out2 = 0.0f;
    219 	_phasor.advancePhase();
    220 	if (mix > 0.0f) {
    221 		_saw.setFrequency(frequency);
    222 		_square.setFrequency(frequency);
    223 		out += _saw.nextFromPhasor(_phasor) * mix;
    224 		out2 += _square.nextFromPhasor(_phasor) * mix;
    225 	}
    226 
    227 	if (oMix > 0.0f) {
    228 		float sawBuf[OVERSAMPLEN] {};
    229 		float squareBuf[OVERSAMPLEN] {};
    230 		_saw.setFrequency(frequency / (float)OVERSAMPLEN);
    231 		_square.setFrequency(frequency / (float)OVERSAMPLEN);
    232 
    233 		for (int i = 0; i < OVERSAMPLEN; ++i) {
    234 			_oversampledPhasor.advancePhase();
    235 			sawBuf[i] = _saw.nextFromPhasor(_oversampledPhasor);
    236 			squareBuf[i] = _square.nextFromPhasor(_oversampledPhasor);
    237 		}
    238 
    239 		out += _sawDecimator.next(sawBuf) * oMix;
    240 		// out += _sawRackDecimator.process(sawBuf) * oMix;
    241 
    242 		out2 += _squareDecimator.next(squareBuf) * oMix;
    243 		// out2 += _squareRackDecimator.process(squareBuf) * oMix;
    244 	}
    245 	else {
    246 		for (int i = 0; i < OVERSAMPLEN; ++i) {
    247 			_oversampledPhasor.advancePhase();
    248 		}
    249 	}
    250 
    251 	outputs[OUT_OUTPUT].setVoltage(out * 5.0f);
    252 	outputs[OUT2_OUTPUT].setVoltage(out2 * 5.0f);
    253 
    254 #elif DECIMATORS
    255 	const int quality = 12;
    256 	float sampleRate = APP->engine->getSampleRate();
    257 	float frequency = oscillatorPitch(15000.0);
    258 	_saw.setSampleRate(sampleRate);
    259 	_saw.setFrequency(frequency / (float)OVERSAMPLEN);
    260 	_saw.setQuality(quality);
    261 	_cicDecimator.setParams(sampleRate, OVERSAMPLEN);
    262 	_lpfDecimator.setParams(sampleRate, OVERSAMPLEN);
    263 
    264 	float buf[OVERSAMPLEN] {};
    265 	for (int i = 0; i < OVERSAMPLEN; ++i) {
    266 		buf[i] = _saw.next();
    267 	}
    268 	outputs[OUT_OUTPUT].setVoltage(_cicDecimator.next(buf) * 5.0f);
    269 	// outputs[OUT2_OUTPUT].setVoltage(_lpfDecimator.next(buf) * 5.0f);
    270 	outputs[OUT2_OUTPUT].setVoltage(_rackDecimator.process(buf) * 5.0f);
    271 
    272 #elif INTERPOLATOR
    273 	const int quality = 12;
    274 	float sampleRate = APP->engine->getSampleRate();
    275 	float frequency = oscillatorPitch();
    276 	_saw.setSampleRate(sampleRate);
    277 	_saw.setFrequency(frequency);
    278 	_saw.setQuality(quality);
    279 	_decimator.setParams(sampleRate, FACTOR);
    280 	_interpolator.setParams(sampleRate, FACTOR);
    281 
    282 	if (_steps >= FACTOR) {
    283 		_steps = 0;
    284 		for (int i = 0; i < FACTOR; ++i) {
    285 			_rawSamples[i] = _saw.next();
    286 		}
    287 		_interpolator.next(_decimator.next(_rawSamples), _processedSamples);
    288 	}
    289 	outputs[OUT_OUTPUT].setVoltage(_processedSamples[_steps] * 5.0f);
    290 	outputs[OUT2_OUTPUT].setVoltage(_rawSamples[_steps] * 5.0f);
    291 	++_steps;
    292 
    293 #elif FM
    294 	const float amplitude = 5.0f;
    295 	float baseHz = oscillatorPitch();
    296 	float ratio = ratio2();
    297 	float index = index3();
    298 	float sampleRate = APP->engine->getSampleRate();
    299 	if (_baseHz != baseHz || _ratio != ratio || _index != index || _sampleRate != sampleRate) {
    300 		_baseHz = baseHz;
    301 		_ratio = ratio;
    302 		_index = index;
    303 		_sampleRate = sampleRate;
    304 		float modHz = _ratio * _baseHz;
    305 		// printf("baseHz=%f ratio=%f modHz=%f index=%f\n", _baseHz, _ratio, modHz, _index);
    306 
    307 		_modulator.setFrequency(modHz);
    308 		_modulator.setSampleRate(_sampleRate);
    309 		_carrier.setSampleRate(_sampleRate);
    310 
    311 		_carrier2.setSampleRate(APP->engine->getSampleRate());
    312 		_carrier2.setFrequency(baseHz);
    313 		_modulator2.setSampleRate(APP->engine->getSampleRate());
    314 		_modulator2.setFrequency(modHz);
    315 	}
    316 
    317 	// linear FM.
    318 	float modHz = _ratio * _baseHz;
    319 	_carrier.setFrequency(_baseHz + _index * _modulator.next() * modHz); // linear FM requires knowing the modulator's frequency.
    320 	outputs[OUT_OUTPUT].setVoltage(_carrier.next() * amplitude);
    321 
    322 	// PM for comparison - identical output.
    323 	_carrier2.advancePhase();
    324 	outputs[OUT2_OUTPUT].setVoltage(_carrier2.nextFromPhasor(_carrier2, Phasor::radiansToPhase(_index * _modulator2.next())) * amplitude);
    325 
    326 #elif PM
    327 	const float amplitude = 5.0f;
    328 	float baseHz = oscillatorPitch();
    329 	float modHz = ratio2() * baseHz;
    330 	_carrier.setSampleRate(APP->engine->getSampleRate());
    331 	_carrier.setFrequency(baseHz);
    332 	_modulator.setSampleRate(APP->engine->getSampleRate());
    333 	_modulator.setFrequency(modHz);
    334 	_carrier.advancePhase();
    335 	outputs[OUT_OUTPUT].setVoltage(_carrier.nextFromPhasor(_carrier, Phasor::radiansToPhase(index3() * _modulator.next())) * amplitude);
    336 
    337 #elif FEEDBACK_PM
    338 	_carrier.setSampleRate(APP->engine->getSampleRate());
    339 	_carrier.setFrequency(oscillatorPitch());
    340 	float feedback = params[PARAM2_PARAM].getValue();
    341 	if (inputs[CV2_INPUT].isConnected()) {
    342 		feedback *= clamp(inputs[CV2_INPUT].getVoltage(), 0.0f, 10.0f) / 10.0f;
    343 	}
    344 	_carrier.advancePhase();
    345 	outputs[OUT_OUTPUT].setVoltage(_feedbackSample = _carrier.nextFromPhasor(_carrier, Phasor::radiansToPhase(feedback * _feedbackSample)) * 5.0f);
    346 
    347 #elif EG
    348 	_envelope.setSampleRate(APP->engine->getSampleRate());
    349 	_envelope.setAttack(params[PARAM1_PARAM].getValue());
    350 	_envelope.setDecay(params[PARAM2_PARAM].getValue());
    351 	_envelope.setSustain(params[PARAM3_PARAM].getValue());
    352 	_envelope.setRelease(params[PARAM2_PARAM].getValue());
    353 	_envelope.setGate(inputs[CV1_INPUT].getVoltage() > 0.1f);
    354 	outputs[OUT_OUTPUT].setVoltage(_envelope.next() * 10.0f);
    355 
    356 #elif TABLES
    357 	_sine.setSampleRate(APP->engine->getSampleRate());
    358 	_sine.setFrequency(oscillatorPitch());
    359 	outputs[OUT_OUTPUT].setVoltage(_sine.next() * 5.0f);
    360 
    361 	_table.setSampleRate(APP->engine->getSampleRate());
    362 	_table.setFrequency(oscillatorPitch());
    363 	outputs[OUT2_OUTPUT].setVoltage(_table.next() * 5.0f);
    364 
    365 #elif SLEW
    366 	float ms = params[PARAM1_PARAM].getValue();
    367 	if (inputs[CV1_INPUT].isConnected()) {
    368 		ms *= clamp(inputs[CV2_INPUT].getVoltage(), 0.0f, 10.0f) / 10.0f;
    369 	}
    370 	ms = powf(ms, 2.0f);
    371 	ms *= 10000.0f;
    372 	_slew.setParams(APP->engine->getSampleRate(), ms);
    373 	outputs[OUT_OUTPUT].setVoltage(_slew.next(inputs[IN_INPUT].getVoltage()));
    374 
    375 	float shape = params[PARAM2_PARAM].getValue();
    376 	if (inputs[CV2_INPUT].isConnected()) {
    377 		shape *= clamp(inputs[CV2_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
    378 	}
    379 	if (shape < 0.5) {
    380 		shape /= 0.5;
    381 		shape = _slew2.minShape + shape * (1.0f - _slew2.minShape);
    382 	}
    383 	else {
    384 		shape -= 0.5f;
    385 		shape /= 0.5f;
    386 		shape *= (_slew2.maxShape - 1.0f);
    387 		shape += 1.0f;
    388 	}
    389 	_slew2.setParams(APP->engine->getSampleRate(), ms, shape);
    390 	outputs[OUT2_OUTPUT].setVoltage(_slew2.next(inputs[IN_INPUT].getVoltage()));
    391 
    392 #elif RMS
    393 	float sensitivity = params[PARAM2_PARAM].getValue();
    394 	if (inputs[CV2_INPUT].isConnected()) {
    395 		sensitivity *= clamp(inputs[CV2_INPUT].getVoltage(), 0.0f, 10.0f) / 10.0f;
    396 	}
    397 	_rms.setSampleRate(APP->engine->getSampleRate());
    398 	_rms.setSensitivity(sensitivity);
    399 	outputs[OUT_OUTPUT].setVoltage(_rms.next(inputs[IN_INPUT].getVoltage()));
    400 	_pef.setParams(APP->engine->getSampleRate(), sensitivity);
    401 	outputs[OUT2_OUTPUT].setVoltage(_pef.next(inputs[IN_INPUT].getVoltage()));
    402 
    403 #elif FASTRMS
    404 	float sensitivity = params[PARAM2_PARAM].getValue();
    405 	if (inputs[CV2_INPUT].isConnected()) {
    406 		sensitivity *= clamp(inputs[CV2_INPUT].getVoltage(), 0.0f, 10.0f) / 10.0f;
    407 	}
    408 	_pure.setSampleRate(APP->engine->getSampleRate());
    409 	_pure.setSensitivity(sensitivity);
    410 	outputs[OUT_OUTPUT].setVoltage(_pure.next(inputs[IN_INPUT].getVoltage()));
    411 	_fast.setSampleRate(APP->engine->getSampleRate());
    412 	_fast.setSensitivity(sensitivity);
    413 	outputs[OUT2_OUTPUT].setVoltage(_fast.next(inputs[IN_INPUT].getVoltage()));
    414 
    415 #elif RAVG
    416 	if (_reset.process(inputs[CV1_INPUT].getVoltage())) {
    417 		_average.reset();
    418 	}
    419 	outputs[OUT_OUTPUT].setVoltage(_average.next(inputs[IN_INPUT].getVoltage()));
    420 
    421 #elif SATURATOR
    422 	float in = inputs[IN_INPUT].getVoltage();
    423 	outputs[OUT_OUTPUT].setVoltage(_saturator.next(in));
    424 	outputs[OUT2_OUTPUT].setVoltage(clamp(in, -Saturator::limit, Saturator::limit));
    425 
    426 #elif BROWNIAN
    427 	const float maxDiv = 1000.0f;
    428 	float change = clamp(1.0f - params[PARAM1_PARAM].getValue(), 0.01f, 1.0f);
    429 	float smooth = clamp(params[PARAM2_PARAM].getValue(), 0.01f, 1.0f);
    430 	smooth *= smooth;
    431 	_filter1.setParams(APP->engine->getSampleRate(), smooth * APP->engine->getSampleRate() * 0.49f);
    432 	_filter2.setParams(APP->engine->getSampleRate(), smooth * APP->engine->getSampleRate() * 0.49f);
    433 
    434 	_last1 = _last1 + _noise1.next() / (change * maxDiv);
    435 	outputs[OUT_OUTPUT].setVoltage(_filter1.next(_last1));
    436 	if (_last1 > 5.0f || _last1 < -5.0f) {
    437 		_last1 = 0.0f;
    438 	}
    439 
    440 	_last2 = _last2 + _noise1.next() / (change * maxDiv);
    441 	outputs[OUT2_OUTPUT].setVoltage(_filter2.next(_last2));
    442 	if (_last2 > 5.0f || _last2 < -5.0f) {
    443 		_last2 = 0.0f;
    444 	}
    445 
    446 #elif INTEGRATOR
    447 	float alpha = params[PARAM1_PARAM].getValue();
    448 	alpha = clamp(alpha*alpha, 0.0f, 1.0f);
    449 	_integrator.setParams(alpha);
    450 
    451 	float sample = 0.0f;
    452 	if (inputs[IN_INPUT].isConnected()) {
    453 		sample = inputs[IN_INPUT].getVoltage();
    454 	}
    455 	else {
    456 		sample = 5.0f * _noise.next();
    457 	}
    458 
    459 	outputs[OUT_OUTPUT].setVoltage(_integrator.next(sample));
    460 	outputs[OUT2_OUTPUT].setVoltage(sample);
    461 
    462 #elif RANDOMWALK
    463 	float change = params[PARAM1_PARAM].getValue();
    464 	change *= change;
    465 	change *= change;
    466 	_walk1.setParams(APP->engine->getSampleRate(), change);
    467 	_walk2.setParams(APP->engine->getSampleRate(), change);
    468 	outputs[OUT_OUTPUT].setVoltage(_walk1.next());
    469 	outputs[OUT2_OUTPUT].setVoltage(_walk2.next());
    470 
    471 #elif DCBLOCKER
    472 	float in = inputs[IN_INPUT].getVoltage();
    473 	outputs[OUT_OUTPUT].setVoltage(_filter.next(in));
    474 	outputs[OUT2_OUTPUT].setVoltage(in);
    475 
    476 #elif LFO_SMOOTHER
    477 	float frequency = params[PARAM1_PARAM].getValue();
    478 	frequency *= 2.0f;
    479 	frequency -= 1.0f;
    480 	frequency *= 5.0f;
    481 	frequency += inputs[CV1_INPUT].getVoltage();
    482 	frequency = clamp(frequency, -5.0f, 5.0f);
    483 	frequency -= 7.0f;
    484 	frequency = cvToFrequency(frequency);
    485 
    486 	float amount = params[PARAM2_PARAM].getValue();
    487 	// amount *= amount;
    488 
    489 	_smoother.setParams(APP->engine->getSampleRate(), frequency, amount);
    490 	float in = inputs[IN_INPUT].getVoltage();
    491 	outputs[OUT_OUTPUT].setVoltage(_smoother.next(in));
    492 
    493 #elif STEPPED_RANDOM
    494 	const float octaves = 7.0f;
    495 	float frequency = params[PARAM1_PARAM].getValue();
    496 	frequency *= 2.0f;
    497 	frequency -= 1.0f;
    498 	frequency *= octaves;
    499 	frequency += inputs[CV1_INPUT].getVoltage();
    500 	frequency = clamp(frequency, -octaves, octaves);
    501 	// frequency -= 4.0f;
    502 	frequency = cvToFrequency(frequency);
    503 	frequency = std::min(frequency, 0.49f*APP->engine->getSampleRate());
    504 
    505 	_stepped.setSampleRate(APP->engine->getSampleRate());
    506 	_stepped.setFrequency(frequency);
    507 	if (_trigger.next(inputs[CV3_INPUT].getVoltage())) {
    508 		_stepped.resetPhase();
    509 	}
    510 	outputs[OUT_OUTPUT].setVoltage(_stepped.next() * 5.0f);
    511 
    512 	if ((_stepped._phase / SteppedRandomOscillator::cyclePhase) > (_lastPhase / SteppedRandomOscillator::cyclePhase)) {
    513 		_lastPhase = _stepped._phase;
    514 		_lastNoise = _noise.next() * 5.0f;
    515 	}
    516 	outputs[OUT2_OUTPUT].setVoltage(_lastNoise);
    517 #endif
    518 }
    519 
    520 float Test::oscillatorPitch(float max) {
    521 	if (inputs[CV1_INPUT].isConnected()) {
    522 		return cvToFrequency(inputs[CV1_INPUT].getVoltage());
    523 	}
    524 	return max * powf(params[PARAM1_PARAM].getValue(), 2.0);
    525 }
    526 
    527 float Test::oscillatorPitch2(float max) {
    528 	if (inputs[CV2_INPUT].isConnected()) {
    529 		return cvToFrequency(inputs[CV2_INPUT].getVoltage());
    530 	}
    531 	return max * powf(params[PARAM2_PARAM].getValue(), 2.0);
    532 }
    533 
    534 float Test::ratio2() {
    535 	float ratio = (params[PARAM2_PARAM].getValue() * 2.0f) - 1.0f;
    536 	if (inputs[CV2_INPUT].isConnected()) {
    537 		ratio *= clamp(inputs[CV2_INPUT].getVoltage() / 5.0f, -1.0f, 1.0f);
    538 	}
    539 	if (ratio < 0.0f) {
    540 		return 1.0f + ratio;
    541 	}
    542 	return 1.0f + 9.0f*ratio;
    543 }
    544 
    545 float Test::index3() {
    546 	float index = params[PARAM3_PARAM].getValue();
    547 	if (inputs[CV3_INPUT].isConnected()) {
    548 		index *= clamp(inputs[CV3_INPUT].getVoltage(), 0.0f, 10.0f) / 10.0f;
    549 	}
    550 	return index * 10.0f;
    551 }
    552 
    553 
    554 struct TestWidget : BGModuleWidget {
    555 	static constexpr int hp = 3;
    556 
    557 	TestWidget(Test* module) {
    558 		setModule(module);
    559 		box.size = Vec(RACK_GRID_WIDTH * hp, RACK_GRID_HEIGHT);
    560 		setPanel(box.size, "Test");
    561 		createScrews();
    562 
    563 		// generated by svg_widgets.rb
    564 		auto param1ParamPosition = Vec(9.5, 13.5);
    565 		auto param2ParamPosition = Vec(9.5, 98.5);
    566 		auto param3ParamPosition = Vec(9.5, 183.5);
    567 
    568 		auto cv1InputPosition = Vec(10.5, 53.0);
    569 		auto cv2InputPosition = Vec(10.5, 138.0);
    570 		auto cv3InputPosition = Vec(10.5, 223.0);
    571 		auto inInputPosition = Vec(10.5, 268.0);
    572 
    573 		auto outOutputPosition = Vec(10.5, 306.0);
    574 		auto out2OutputPosition = Vec(20.5, 316.0);
    575 		// end generated by svg_widgets.rb
    576 
    577 		addParam(createParam<Knob26>(param1ParamPosition, module, Test::PARAM1_PARAM));
    578 		addParam(createParam<Knob26>(param2ParamPosition, module, Test::PARAM2_PARAM));
    579 		addParam(createParam<Knob26>(param3ParamPosition, module, Test::PARAM3_PARAM));
    580 
    581 		addInput(createInput<Port24>(cv1InputPosition, module, Test::CV1_INPUT));
    582 		addInput(createInput<Port24>(cv2InputPosition, module, Test::CV2_INPUT));
    583 		addInput(createInput<Port24>(cv3InputPosition, module, Test::CV3_INPUT));
    584 		addInput(createInput<Port24>(inInputPosition, module, Test::IN_INPUT));
    585 
    586 		addOutput(createOutput<Port24>(outOutputPosition, module, Test::OUT_OUTPUT));
    587 		addOutput(createOutput<Port24>(out2OutputPosition, module, Test::OUT2_OUTPUT));
    588 	}
    589 };
    590 
    591 Model* modelTest = bogaudio::createModel<Test, TestWidget>("Bogaudio-Test", "TEST", "test");