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");