VCVRack
/
Befaco
mirror of https://github.com/VCVRack/Befaco.git
1
0
Fork 0
Code Issues 0 Releases 17 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
170 Commits
7 Branches
39MB
Tree: 4c55f11721
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4c55f11721'
${ noResults }
Befaco/src/Rampage.cpp

406 lines
16KB
Raw Blame History 

  1. #include "plugin.hpp"

  2. 

  3. using simd::float_4;

  4. 

  5. static float_4 shapeDelta(float_4 delta, float_4 tau, float shape) {

  6. 	float_4 lin = simd::sgn(delta) * 10.f / tau;

  7. 	if (shape < 0.f) {

  8. 		float_4 log = simd::sgn(delta) * 40.f / tau / (simd::fabs(delta) + 1.f);

  9. 		return simd::crossfade(lin, log, -shape * 0.95f);

  10. 	}

  11. 	else {

  12. 		float_4 exp = M_E * delta / tau;

  13. 		return simd::crossfade(lin, exp, shape * 0.90f);

  14. 	}

  15. }

  16. 

  17. struct Rampage : Module {

  18. 	enum ParamIds {

  19. 		RANGE_A_PARAM,

  20. 		RANGE_B_PARAM,

  21. 		SHAPE_A_PARAM,

  22. 		SHAPE_B_PARAM,

  23. 		TRIGG_A_PARAM,

  24. 		TRIGG_B_PARAM,

  25. 		RISE_A_PARAM,

  26. 		RISE_B_PARAM,

  27. 		FALL_A_PARAM,

  28. 		FALL_B_PARAM,

  29. 		CYCLE_A_PARAM,

  30. 		CYCLE_B_PARAM,

  31. 		BALANCE_PARAM,

  32. 		NUM_PARAMS

  33. 	};

  34. 	enum InputIds {

  35. 		IN_A_INPUT,

  36. 		IN_B_INPUT,

  37. 		TRIGG_A_INPUT,

  38. 		TRIGG_B_INPUT,

  39. 		RISE_CV_A_INPUT,

  40. 		RISE_CV_B_INPUT,

  41. 		FALL_CV_A_INPUT,

  42. 		FALL_CV_B_INPUT,

  43. 		EXP_CV_A_INPUT,

  44. 		EXP_CV_B_INPUT,

  45. 		CYCLE_A_INPUT,

  46. 		CYCLE_B_INPUT,

  47. 		NUM_INPUTS

  48. 	};

  49. 	enum OutputIds {

  50. 		RISING_A_OUTPUT,

  51. 		RISING_B_OUTPUT,

  52. 		FALLING_A_OUTPUT,

  53. 		FALLING_B_OUTPUT,

  54. 		EOC_A_OUTPUT,

  55. 		EOC_B_OUTPUT,

  56. 		OUT_A_OUTPUT,

  57. 		OUT_B_OUTPUT,

  58. 		COMPARATOR_OUTPUT,

  59. 		MIN_OUTPUT,

  60. 		MAX_OUTPUT,

  61. 		NUM_OUTPUTS

  62. 	};

  63. 	enum LightIds {

  64. 		ENUMS(COMPARATOR_LIGHT, 3),

  65. 		ENUMS(MIN_LIGHT, 3),

  66. 		ENUMS(MAX_LIGHT, 3),

  67. 		ENUMS(OUT_A_LIGHT, 3),

  68. 		ENUMS(OUT_B_LIGHT, 3),

  69. 		ENUMS(RISING_A_LIGHT, 3),

  70. 		ENUMS(RISING_B_LIGHT, 3),

  71. 		ENUMS(FALLING_A_LIGHT, 3),

  72. 		ENUMS(FALLING_B_LIGHT, 3),

  73. 		NUM_LIGHTS

  74. 	};

  75. 

  76. 

  77. 	float_4 out[2][4] = {};

  78. 	float_4 gate[2][4] = {}; // use simd __m128 logic instead of bool

  79. 

  80. 	dsp::TSchmittTrigger<float_4> trigger_4[2][4];

  81. 	PulseGenerator_4 endOfCyclePulse[2][4];

  82. 

  83. 	// ChannelMask channelMask;

  84. 

  85. 	Rampage() {

  86. 		config(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS);

  87. 		configSwitch(RANGE_A_PARAM, 0.0, 2.0, 0.0, "Ch 1 range", {"Medium", "Fast", "Slow"});

  88. 		configParam(SHAPE_A_PARAM, -1.0, 1.0, 0.0, "Ch 1 shape");

  89. 		configButton(TRIGG_A_PARAM, "Ch 1 trigger");

  90. 		configParam(RISE_A_PARAM, 0.0, 1.0, 0.0, "Ch 1 rise time");

  91. 		configParam(FALL_A_PARAM, 0.0, 1.0, 0.0, "Ch 1 fall time");

  92. 		configSwitch(CYCLE_A_PARAM, 0.0, 1.0, 0.0, "Ch 1 cycle", {"Off", "On"});

  93. 		configSwitch(RANGE_B_PARAM, 0.0, 2.0, 0.0, "Ch 2 range", {"Medium", "Fast", "Slow"});

  94. 		configParam(SHAPE_B_PARAM, -1.0, 1.0, 0.0, "Ch 2 shape");

  95. 		configButton(TRIGG_B_PARAM, "Ch 2 trigger");

  96. 		configParam(RISE_B_PARAM, 0.0, 1.0, 0.0, "Ch 2 rise time");

  97. 		configParam(FALL_B_PARAM, 0.0, 1.0, 0.0, "Ch 2 fall time");

  98. 		configSwitch(CYCLE_B_PARAM, 0.0, 1.0, 0.0, "Ch 2 cycle", {"Off", "On"});

  99. 		configParam(BALANCE_PARAM, 0.0, 1.0, 0.5, "Balance");

  100. 

  101. 		configInput(IN_A_INPUT, "A");

  102. 		configInput(IN_B_INPUT, "B");

  103. 		configInput(TRIGG_A_INPUT, "Trigger A");

  104. 		configInput(TRIGG_B_INPUT, "Trigger B");

  105. 		configInput(RISE_CV_A_INPUT, "Rise CV A");

  106. 		configInput(RISE_CV_B_INPUT, "Rise CV B");

  107. 		configInput(FALL_CV_A_INPUT, "Fall CV A");

  108. 		configInput(FALL_CV_B_INPUT, "Fall CV B");

  109. 		configInput(EXP_CV_A_INPUT, "Exponetial CV A");

  110. 		configInput(EXP_CV_B_INPUT, "Exponetial CV B");

  111. 		configInput(CYCLE_A_INPUT, "Cycle A");

  112. 		configInput(CYCLE_B_INPUT, "Cycle B");

  113. 

  114. 		configOutput(RISING_A_OUTPUT, "Rising A");

  115. 		configOutput(RISING_B_OUTPUT, "Rising B");

  116. 		configOutput(FALLING_A_OUTPUT, "Falling A");

  117. 		configOutput(FALLING_B_OUTPUT, "Falling B");

  118. 		configOutput(EOC_A_OUTPUT, "End of cycle A");

  119. 		configOutput(EOC_B_OUTPUT, "End of cycle B");

  120. 		configOutput(OUT_A_OUTPUT, "A");

  121. 		configOutput(OUT_B_OUTPUT, "B");

  122. 		configOutput(COMPARATOR_OUTPUT, "B > A");

  123. 		configOutput(MIN_OUTPUT, "Minimum of A and B");

  124. 		configOutput(MAX_OUTPUT, "Maximum of A and B");

  125. 	}

  126. 

  127. 	void process(const ProcessArgs& args) override {

  128. 		int channels_in[2] = {};

  129. 		int channels_trig[2] = {};

  130. 		int channels[2] = {}; 	// the larger of in or trig (per-part)

  131. 

  132. 		// determine number of channels:

  133. 

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

  135. 

  136. 			channels_in[part]   = inputs[IN_A_INPUT + part].getChannels();

  137. 			channels_trig[part] = inputs[TRIGG_A_INPUT + part].getChannels();

  138. 			channels[part] = std::max(channels_in[part], channels_trig[part]);

  139. 			channels[part] = std::max(1, channels[part]);

  140. 

  141. 			outputs[OUT_A_OUTPUT + part].setChannels(channels[part]);

  142. 			outputs[RISING_A_OUTPUT + part].setChannels(channels[part]);

  143. 			outputs[FALLING_A_OUTPUT + part].setChannels(channels[part]);

  144. 			outputs[EOC_A_OUTPUT + part].setChannels(channels[part]);

  145. 		}

  146. 

  147. 		// total number of active polyphony engines, accounting for both halves

  148. 		// (channels[0] / channels[1] are the number of active engines per section)

  149. 		const int channels_max = std::max(channels[0], channels[1]);

  150. 

  151. 		outputs[COMPARATOR_OUTPUT].setChannels(channels_max);

  152. 		outputs[MIN_OUTPUT].setChannels(channels_max);

  153. 		outputs[MAX_OUTPUT].setChannels(channels_max);

  154. 

  155. 		// loop over two parts of Rampage:

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

  157. 

  158. 			float_4 in[4] = {};

  159. 			float_4 in_trig[4] = {};

  160. 			float_4 riseCV[4] = {};

  161. 			float_4 fallCV[4] = {};

  162. 			float_4 cycle[4] = {};

  163. 

  164. 			// get parameters:

  165. 			float minTime;

  166. 			switch ((int) params[RANGE_A_PARAM + part].getValue()) {

  167. 				case 0:

  168. 					minTime = 1e-2;

  169. 					break;

  170. 				case 1:

  171. 					minTime = 1e-3;

  172. 					break;

  173. 				default:

  174. 					minTime = 1e-1;

  175. 					break;

  176. 			}

  177. 

  178. 			float_4 param_rise  = params[RISE_A_PARAM  + part].getValue() * 10.0f;

  179. 			float_4 param_fall  = params[FALL_A_PARAM  + part].getValue() * 10.0f;

  180. 			float_4 param_trig  = params[TRIGG_A_PARAM + part].getValue() * 20.0f;

  181. 			float_4 param_cycle = params[CYCLE_A_PARAM + part].getValue() * 10.0f;

  182. 

  183. 			for (int c = 0; c < channels[part]; c += 4) {

  184. 				riseCV[c / 4] = param_rise;

  185. 				fallCV[c / 4] = param_fall;

  186. 				cycle[c / 4] = param_cycle;

  187. 				in_trig[c / 4] = param_trig;

  188. 			}

  189. 

  190. 			// read inputs:

  191. 			if (inputs[IN_A_INPUT + part].isConnected()) {

  192. 				for (int c = 0; c < channels[part]; c += 4)

  193. 					in[c / 4] = inputs[IN_A_INPUT + part].getPolyVoltageSimd<float_4>(c);

  194. 			}

  195. 

  196. 			if (inputs[TRIGG_A_INPUT + part].isConnected()) {

  197. 				for (int c = 0; c < channels[part]; c += 4)

  198. 					in_trig[c / 4] += inputs[TRIGG_A_INPUT + part].getPolyVoltageSimd<float_4>(c);

  199. 			}

  200. 

  201. 			if (inputs[EXP_CV_A_INPUT + part].isConnected()) {

  202. 				float_4 expCV[4] = {};

  203. 				for (int c = 0; c < channels[part]; c += 4)

  204. 					expCV[c / 4] = inputs[EXP_CV_A_INPUT + part].getPolyVoltageSimd<float_4>(c);

  205. 

  206. 				for (int c = 0; c < channels[part]; c += 4) {

  207. 					riseCV[c / 4] -= expCV[c / 4];

  208. 					fallCV[c / 4] -= expCV[c / 4];

  209. 				}

  210. 			}

  211. 

  212. 			for (int c = 0; c < channels[part]; c += 4)

  213. 				riseCV[c / 4] += inputs[RISE_CV_A_INPUT + part].getPolyVoltageSimd<float_4>(c);

  214. 			for (int c = 0; c < channels[part]; c += 4)

  215. 				fallCV[c / 4] += inputs[FALL_CV_A_INPUT + part].getPolyVoltageSimd<float_4>(c);

  216. 			for (int c = 0; c < channels[part]; c += 4)

  217. 				cycle[c / 4] += inputs[CYCLE_A_INPUT + part].getPolyVoltageSimd<float_4>(c);

  218. 

  219. 			// start processing:

  220. 			for (int c = 0; c < channels[part]; c += 4) {

  221. 

  222. 				// process SchmittTriggers

  223. 				float_4 trig_mask = trigger_4[part][c / 4].process(in_trig[c / 4] / 2.0, 0.1, 2.0);

  224. 				gate[part][c / 4] = ifelse(trig_mask, float_4::mask(), gate[part][c / 4]);

  225. 				in[c / 4] = ifelse(gate[part][c / 4], 10.0f, in[c / 4]);

  226. 

  227. 				float_4 delta = in[c / 4] - out[part][c / 4];

  228. 

  229. 				// rise / fall branching

  230. 				float_4 delta_gt_0 = delta > 0.f;

  231. 				float_4 delta_lt_0 = delta < 0.f;

  232. 				float_4 delta_eq_0 = ~(delta_lt_0 | delta_gt_0);

  233. 

  234. 				float_4 rateCV = ifelse(delta_gt_0, riseCV[c / 4], 0.f);

  235. 				rateCV = ifelse(delta_lt_0, fallCV[c / 4], rateCV);

  236. 				rateCV = clamp(rateCV, 0.f, 10.0f);

  237. 

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

  239. 

  240. 				float shape = params[SHAPE_A_PARAM + part].getValue();

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

  242. 

  243. 				float_4 rising  = simd::ifelse(delta_gt_0, (in[c / 4] - out[part][c / 4]) > 1e-3f, float_4::zero());

  244. 				float_4 falling = simd::ifelse(delta_lt_0, (in[c / 4] - out[part][c / 4]) < -1e-3f, float_4::zero());

  245. 

  246. 				float_4 end_of_cycle = simd::andnot(falling, delta_lt_0);

  247. 

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

  249. 

  250. 				gate[part][c / 4] = ifelse(simd::andnot(rising, delta_gt_0), 0.f, gate[part][c / 4]);

  251. 				gate[part][c / 4] = ifelse(end_of_cycle & (cycle[c / 4] >= 4.0f), float_4::mask(), gate[part][c / 4]);

  252. 				gate[part][c / 4] = ifelse(delta_eq_0, 0.f, gate[part][c / 4]);

  253. 

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

  255. 

  256. 				float_4 out_rising  = ifelse(rising, 10.0f, 0.f);

  257. 				float_4 out_falling = ifelse(falling, 10.0f, 0.f);

  258. 

  259. 				float_4 pulse = endOfCyclePulse[part][c / 4].process(args.sampleTime);

  260. 				float_4 out_EOC = ifelse(pulse, 10.f, 0.f);

  261. 

  262. 				outputs[OUT_A_OUTPUT + part].setVoltageSimd(out[part][c / 4], c);

  263. 				outputs[RISING_A_OUTPUT + part].setVoltageSimd(out_rising, c);

  264. 				outputs[FALLING_A_OUTPUT + part].setVoltageSimd(out_falling, c);

  265. 				outputs[EOC_A_OUTPUT + part].setVoltageSimd(out_EOC, c);

  266. 

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

  268. 

  269. 			if (channels[part] == 1) {

  270. 				lights[RISING_A_LIGHT + 3 * part  ].setSmoothBrightness(outputs[RISING_A_OUTPUT + part].getVoltage() / 10.f, args.sampleTime);

  271. 				lights[RISING_A_LIGHT + 3 * part + 1].setBrightness(0.0f);

  272. 				lights[RISING_A_LIGHT + 3 * part + 2].setBrightness(0.0f);

  273. 				lights[FALLING_A_LIGHT + 3 * part  ].setSmoothBrightness(outputs[FALLING_A_OUTPUT + part].getVoltage() / 10.f, args.sampleTime);

  274. 				lights[FALLING_A_LIGHT + 3 * part + 1].setBrightness(0.0f);

  275. 				lights[FALLING_A_LIGHT + 3 * part + 2].setBrightness(0.0f);

  276. 				lights[OUT_A_LIGHT + 3 * part  ].setSmoothBrightness(out[part][0].s[0] / 10.0, args.sampleTime);

  277. 				lights[OUT_A_LIGHT + 3 * part + 1].setBrightness(0.0f);

  278. 				lights[OUT_A_LIGHT + 3 * part + 2].setBrightness(0.0f);

  279. 			}

  280. 			else {

  281. 				lights[RISING_A_LIGHT + 3 * part  ].setBrightness(0.0f);

  282. 				lights[RISING_A_LIGHT + 3 * part + 1].setBrightness(0.0f);

  283. 				lights[RISING_A_LIGHT + 3 * part + 2].setBrightness(10.0f);

  284. 				lights[FALLING_A_LIGHT + 3 * part  ].setBrightness(0.0f);

  285. 				lights[FALLING_A_LIGHT + 3 * part + 1].setBrightness(0.0f);

  286. 				lights[FALLING_A_LIGHT + 3 * part + 2].setBrightness(10.0f);

  287. 				lights[OUT_A_LIGHT + 3 * part  ].setBrightness(0.0f);

  288. 				lights[OUT_A_LIGHT + 3 * part + 1].setBrightness(0.0f);

  289. 				lights[OUT_A_LIGHT + 3 * part + 2].setBrightness(10.0f);

  290. 			}

  291. 

  292. 		} // for (int part, ... )

  293. 

  294. 

  295. 		// Logic

  296. 		float balance = params[BALANCE_PARAM].getValue();

  297. 

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

  299. 

  300. 			float_4 a = out[0][c / 4];

  301. 			float_4 b = out[1][c / 4];

  302. 

  303. 			if (balance < 0.5)

  304. 				b *= 2.0f * balance;

  305. 			else if (balance > 0.5)

  306. 				a *= 2.0f * (1.0 - balance);

  307. 

  308. 			float_4 comp = ifelse(b > a, 10.0f, 0.f);

  309. 			float_4 out_min = simd::fmin(a, b);

  310. 			float_4 out_max = simd::fmax(a, b);

  311. 

  312. 			outputs[COMPARATOR_OUTPUT].setVoltageSimd(comp, c);

  313. 			outputs[MIN_OUTPUT].setVoltageSimd(out_min, c);

  314. 			outputs[MAX_OUTPUT].setVoltageSimd(out_max, c);

  315. 		}

  316. 		// Lights

  317. 		if (channels_max == 1) {

  318. 			lights[COMPARATOR_LIGHT  ].setSmoothBrightness(outputs[COMPARATOR_OUTPUT].getVoltage(), args.sampleTime);

  319. 			lights[COMPARATOR_LIGHT + 1].setBrightness(0.0f);

  320. 			lights[COMPARATOR_LIGHT + 2].setBrightness(0.0f);

  321. 			lights[MIN_LIGHT  ].setSmoothBrightness(outputs[MIN_OUTPUT].getVoltage(), args.sampleTime);

  322. 			lights[MIN_LIGHT + 1].setBrightness(0.0f);

  323. 			lights[MIN_LIGHT + 2].setBrightness(0.0f);

  324. 			lights[MAX_LIGHT  ].setSmoothBrightness(outputs[MAX_OUTPUT].getVoltage(), args.sampleTime);

  325. 			lights[MAX_LIGHT + 1].setBrightness(0.0f);

  326. 			lights[MAX_LIGHT + 2].setBrightness(0.0f);

  327. 		}

  328. 		else {

  329. 			lights[COMPARATOR_LIGHT  ].setBrightness(0.0f);

  330. 			lights[COMPARATOR_LIGHT + 1].setBrightness(0.0f);

  331. 			lights[COMPARATOR_LIGHT + 2].setBrightness(10.0f);

  332. 			lights[MIN_LIGHT  ].setBrightness(0.0f);

  333. 			lights[MIN_LIGHT + 1].setBrightness(0.0f);

  334. 			lights[MIN_LIGHT + 2].setBrightness(10.0f);

  335. 			lights[MAX_LIGHT  ].setBrightness(0.0f);

  336. 			lights[MAX_LIGHT + 1].setBrightness(0.0f);

  337. 			lights[MAX_LIGHT + 2].setBrightness(10.0f);

  338. 		}

  339. 	}

  340. };

  341. 

  342. 

  343. struct RampageWidget : ModuleWidget {

  344. 	RampageWidget(Rampage* module) {

  345. 		setModule(module);

  346. 		setPanel(APP->window->loadSvg(asset::plugin(pluginInstance, "res/panels/Rampage.svg")));

  347. 

  348. 		addChild(createWidget<Knurlie>(Vec(15, 0)));

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

  350. 		addChild(createWidget<Knurlie>(Vec(15, 365)));

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

  352. 

  353. 		addParam(createParam<BefacoSwitch>(Vec(94, 32), module, Rampage::RANGE_A_PARAM));

  354. 		addParam(createParam<BefacoTinyKnob>(Vec(27, 90), module, Rampage::SHAPE_A_PARAM));

  355. 		addParam(createParam<BefacoPush>(Vec(72, 82), module, Rampage::TRIGG_A_PARAM));

  356. 		addParam(createParam<BefacoSlidePot>(Vec(16, 135), module, Rampage::RISE_A_PARAM));

  357. 		addParam(createParam<BefacoSlidePot>(Vec(57, 135), module, Rampage::FALL_A_PARAM));

  358. 		addParam(createParam<BefacoSwitch>(Vec(101, 238), module, Rampage::CYCLE_A_PARAM));

  359. 		addParam(createParam<BefacoSwitch>(Vec(147, 32), module, Rampage::RANGE_B_PARAM));

  360. 		addParam(createParam<BefacoTinyKnob>(Vec(217, 90), module, Rampage::SHAPE_B_PARAM));

  361. 		addParam(createParam<BefacoPush>(Vec(170, 82), module, Rampage::TRIGG_B_PARAM));

  362. 		addParam(createParam<BefacoSlidePot>(Vec(197, 135), module, Rampage::RISE_B_PARAM));

  363. 		addParam(createParam<BefacoSlidePot>(Vec(238, 135), module, Rampage::FALL_B_PARAM));

  364. 		addParam(createParam<BefacoSwitch>(Vec(141, 238), module, Rampage::CYCLE_B_PARAM));

  365. 		addParam(createParam<Davies1900hWhiteKnob>(Vec(117, 76), module, Rampage::BALANCE_PARAM));

  366. 

  367. 		addInput(createInput<BefacoInputPort>(Vec(14, 30), module, Rampage::IN_A_INPUT));

  368. 		addInput(createInput<BefacoInputPort>(Vec(52, 37), module, Rampage::TRIGG_A_INPUT));

  369. 		addInput(createInput<BefacoInputPort>(Vec(8, 268), module, Rampage::RISE_CV_A_INPUT));

  370. 		addInput(createInput<BefacoInputPort>(Vec(67, 268), module, Rampage::FALL_CV_A_INPUT));

  371. 		addInput(createInput<BefacoInputPort>(Vec(38, 297), module, Rampage::EXP_CV_A_INPUT));

  372. 		addInput(createInput<BefacoInputPort>(Vec(102, 290), module, Rampage::CYCLE_A_INPUT));

  373. 		addInput(createInput<BefacoInputPort>(Vec(229, 30), module, Rampage::IN_B_INPUT));

  374. 		addInput(createInput<BefacoInputPort>(Vec(192, 37), module, Rampage::TRIGG_B_INPUT));

  375. 		addInput(createInput<BefacoInputPort>(Vec(176, 268), module, Rampage::RISE_CV_B_INPUT));

  376. 		addInput(createInput<BefacoInputPort>(Vec(237, 268), module, Rampage::FALL_CV_B_INPUT));

  377. 		addInput(createInput<BefacoInputPort>(Vec(207, 297), module, Rampage::EXP_CV_B_INPUT));

  378. 		addInput(createInput<BefacoInputPort>(Vec(143, 290), module, Rampage::CYCLE_B_INPUT));

  379. 

  380. 		addOutput(createOutput<BefacoOutputPort>(Vec(8, 326), module, Rampage::RISING_A_OUTPUT));

  381. 		addOutput(createOutput<BefacoOutputPort>(Vec(68, 326), module, Rampage::FALLING_A_OUTPUT));

  382. 		addOutput(createOutput<BefacoOutputPort>(Vec(104, 326), module, Rampage::EOC_A_OUTPUT));

  383. 		addOutput(createOutput<BefacoOutputPort>(Vec(102, 195), module, Rampage::OUT_A_OUTPUT));

  384. 		addOutput(createOutput<BefacoOutputPort>(Vec(177, 326), module, Rampage::RISING_B_OUTPUT));

  385. 		addOutput(createOutput<BefacoOutputPort>(Vec(237, 326), module, Rampage::FALLING_B_OUTPUT));

  386. 		addOutput(createOutput<BefacoOutputPort>(Vec(140, 326), module, Rampage::EOC_B_OUTPUT));

  387. 		addOutput(createOutput<BefacoOutputPort>(Vec(142, 195), module, Rampage::OUT_B_OUTPUT));

  388. 		addOutput(createOutput<BefacoOutputPort>(Vec(122, 133), module, Rampage::COMPARATOR_OUTPUT));

  389. 		addOutput(createOutput<BefacoOutputPort>(Vec(89, 157), module, Rampage::MIN_OUTPUT));

  390. 		addOutput(createOutput<BefacoOutputPort>(Vec(155, 157), module, Rampage::MAX_OUTPUT));

  391. 

  392. 		addChild(createLight<SmallLight<RedGreenBlueLight>>(Vec(132, 167), module, Rampage::COMPARATOR_LIGHT));

  393. 		addChild(createLight<SmallLight<RedGreenBlueLight>>(Vec(123, 174), module, Rampage::MIN_LIGHT));

  394. 		addChild(createLight<SmallLight<RedGreenBlueLight>>(Vec(141, 174), module, Rampage::MAX_LIGHT));

  395. 		addChild(createLight<SmallLight<RedGreenBlueLight>>(Vec(126, 185), module, Rampage::OUT_A_LIGHT));

  396. 		addChild(createLight<SmallLight<RedGreenBlueLight>>(Vec(138, 185), module, Rampage::OUT_B_LIGHT));

  397. 		addChild(createLight<SmallLight<RedGreenBlueLight>>(Vec(18, 312), module, Rampage::RISING_A_LIGHT));

  398. 		addChild(createLight<SmallLight<RedGreenBlueLight>>(Vec(78, 312), module, Rampage::FALLING_A_LIGHT));

  399. 		addChild(createLight<SmallLight<RedGreenBlueLight>>(Vec(187, 312), module, Rampage::RISING_B_LIGHT));

  400. 		addChild(createLight<SmallLight<RedGreenBlueLight>>(Vec(247, 312), module, Rampage::FALLING_B_LIGHT));

  401. 	}

  402. };

  403. 

  404. 

  405. Model* modelRampage = createModel<Rampage, RampageWidget>("Rampage");