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.
61 Commits
7 Branches
7.6MB
Tree: 25eb9cd5a8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '25eb9cd5a8'
${ noResults }
Befaco/src/Rampage.cpp

413 lines
16KB
Raw Blame History 

  1. #include "plugin.hpp"

  2. #include "simd_mask.hpp"

  3. #include "PulseGenerator_4.hpp"

  4. 

  5. #define MAX(a,b) a>b?a:b

  6. 

  7. 

  8. static simd::float_4 shapeDelta(simd::float_4 delta, simd::float_4 tau, float shape) {

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

  10. 	if (shape < 0.f) {

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

  12. 		return crossfade_4(lin, log, -shape * 0.95f);

  13. 	}

  14. 	else {

  15. 		simd::float_4 exp = M_E * delta / tau;

  16. 		return crossfade_4(lin, exp, shape * 0.90f);

  17. 	}

  18. }

  19. 

  20. struct Rampage : Module {

  21. 	enum ParamIds {

  22. 		RANGE_A_PARAM,

  23. 		RANGE_B_PARAM,

  24. 		SHAPE_A_PARAM,

  25. 		SHAPE_B_PARAM,

  26. 		TRIGG_A_PARAM,

  27. 		TRIGG_B_PARAM,

  28. 		RISE_A_PARAM,

  29. 		RISE_B_PARAM,

  30. 		FALL_A_PARAM,

  31. 		FALL_B_PARAM,

  32. 		CYCLE_A_PARAM,

  33. 		CYCLE_B_PARAM,

  34. 		BALANCE_PARAM,

  35. 		NUM_PARAMS

  36. 	};

  37. 	enum InputIds {

  38. 		IN_A_INPUT,

  39. 		IN_B_INPUT,

  40. 		TRIGG_A_INPUT,

  41. 		TRIGG_B_INPUT,

  42. 		RISE_CV_A_INPUT,

  43. 		RISE_CV_B_INPUT,

  44. 		FALL_CV_A_INPUT,

  45. 		FALL_CV_B_INPUT,

  46. 		EXP_CV_A_INPUT,

  47. 		EXP_CV_B_INPUT,

  48. 		CYCLE_A_INPUT,

  49. 		CYCLE_B_INPUT,

  50. 		NUM_INPUTS

  51. 	};

  52. 	enum OutputIds {

  53. 		RISING_A_OUTPUT,

  54. 		RISING_B_OUTPUT,

  55. 		FALLING_A_OUTPUT,

  56. 		FALLING_B_OUTPUT,

  57. 		EOC_A_OUTPUT,

  58. 		EOC_B_OUTPUT,

  59. 		OUT_A_OUTPUT,

  60. 		OUT_B_OUTPUT,

  61. 		COMPARATOR_OUTPUT,

  62. 		MIN_OUTPUT,

  63. 		MAX_OUTPUT,

  64. 		NUM_OUTPUTS

  65. 	};

  66. 	enum LightIds {

  67. 		COMPARATOR_LIGHT,

  68. 		MIN_LIGHT,

  69. 		MAX_LIGHT,

  70. 		OUT_A_LIGHT,

  71. 		OUT_B_LIGHT,

  72. 		RISING_A_LIGHT,

  73. 		RISING_B_LIGHT,

  74. 		FALLING_A_LIGHT,

  75. 		FALLING_B_LIGHT,

  76. 		NUM_LIGHTS

  77. 	};

  78. 

  79. 	/*

  80. 	float out[2] = {};

  81. 	bool gate[2] = {};

  82. 	*/

  83. 

  84. 	simd::float_4 out[2][4];

  85. 	simd::float_4 gate[2][4]; // use simd __m128 logic instead of bool

  86. 

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

  88. 	PulseGenerator_4 endOfCyclePulse[2][4];

  89. 

  90. 	ChannelMask channelMask; 

  91. 

  92. 	Rampage() {

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

  94. 		configParam(RANGE_A_PARAM, 0.0, 2.0, 0.0, "Ch 1 range");

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

  96. 		configParam(TRIGG_A_PARAM, 0.0, 1.0, 0.0, "Ch 1 trigger");

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

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

  99. 		configParam(CYCLE_A_PARAM, 0.0, 1.0, 0.0, "Ch 1 cycle");

  100. 		configParam(RANGE_B_PARAM, 0.0, 2.0, 0.0, "Ch 2 range");

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

  102. 		configParam(TRIGG_B_PARAM, 0.0, 1.0, 0.0, "Ch 2 trigger");

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

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

  105. 		configParam(CYCLE_B_PARAM, 0.0, 1.0, 0.0, "Ch 2 cycle");

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

  107. 

  108. 		memset(out, 0, sizeof(out));

  109. 		memset(gate, 0, sizeof(gate));

  110. 	}

  111. 

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

  113. 

  114. 		int channels_in[2];

  115. 		int channels_trig[2];

  116. 		int channels[2];

  117. 

  118. 		// determine number of channels: 

  119. 

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

  121. 			int tmp = inputs[IN_A_INPUT+part].getChannels();

  122. 			channels_in[part] = MAX(1,tmp);

  123. 			tmp = inputs[TRIGG_A_INPUT+part].getChannels();

  124. 			channels_trig[part] = MAX(1,tmp);

  125. 			channels[part] = MAX(channels_in[part], channels_trig[part]);

  126. 

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

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

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

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

  131. 		}

  132. 		int channels_max = MAX(channels[0], channels[1]);

  133. 

  134. 		// loop over two parts of Rampage:

  135. 

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

  137. 

  138. 			simd::float_4 in[4];

  139. 			simd::float_4 in_trig[4];

  140. 			simd::float_4 expCV[4] = {};

  141. 			simd::float_4 riseCV[4] = {};

  142. 			simd::float_4 fallCV[4] = {};

  143. 			simd::float_4 cycle[4] = {};

  144. 

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

  146. 			float minTime;

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

  148. 				case 0: minTime = 1e-2; break;

  149. 				case 1: minTime = 1e-3; break;

  150. 				default: minTime = 1e-1; break;

  151. 			}

  152. 

  153. 			simd::float_4 param_rise  = simd::float_4(params[RISE_A_PARAM  + part].getValue());

  154. 			simd::float_4 param_fall  = simd::float_4(params[FALL_A_PARAM  + part].getValue());

  155. 			simd::float_4 param_trig  = simd::float_4(params[TRIGG_A_PARAM + part].getValue() * 10.0f);

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

  157. 

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

  159. 				load_input(inputs[IN_A_INPUT + part], in, channels_in[part]);

  160. 				channelMask.apply_all(in, channels_in[part]);

  161. 			} else {

  162. 				memset(in, 0, sizeof(in));

  163. 			}

  164. 

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

  166. 				load_input(inputs[TRIGG_A_INPUT + part], in_trig, channels_trig[part]);

  167. 				channelMask.apply_all(in_trig, channels_trig[part]);

  168. 			} else {

  169. 				memset(in_trig, 0, sizeof(in_trig));

  170. 			}	

  171. 

  172. 			for(int c=0; c<channels_trig[part]; c+=4) in_trig[c/4] = param_trig + in_trig[c/4]/2.0f;

  173. 			channelMask.apply_all(in_trig, channels_trig[part] );

  174. 			

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

  176. 				simd::float_4 trig_mask = trigger_4[part][c/4].process(in_trig[c/4]);

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

  178. 				in[c/4] = ifelse(gate[part][c/4], simd::float_4(10.0f), in[c/4]);

  179. 			}

  180. 

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

  182. 				load_input(inputs[EXP_CV_A_INPUT + part], expCV, channels[part]);

  183. 				for(int c=0; c<channels[part]; c+=4) riseCV[c/4] *= -1.0f;

  184. 			}

  185. 

  186. 			load_input(inputs[RISE_CV_A_INPUT + part], riseCV, channels[part]);

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

  188. 				riseCV[c/4] += expCV[c/4];

  189. 				riseCV[c/4] *= 0.10f;

  190. 				riseCV[c/4] += param_rise;

  191. 			}

  192. 

  193. 			load_input(inputs[FALL_CV_A_INPUT + part], fallCV, channels[part]);

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

  195. 				fallCV[c/4] += expCV[c/4];

  196. 				fallCV[c/4] *= 0.10f;

  197. 				fallCV[c/4] += param_fall;

  198. 			}

  199. 

  200. 			load_input(inputs[CYCLE_A_INPUT], cycle, channels[part]);

  201. 			// channelMask.apply_all(cycle, channels[part]);

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

  203. 				cycle[c/4] += param_cycle;

  204. 			}

  205. 			channelMask.apply_all(cycle, channels[part]);

  206. 

  207. 

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

  209. 

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

  211. 

  212. 				simd::float_4 delta_gt_0 = delta > simd::float_4::zero();

  213. 				simd::float_4 delta_lt_0 = delta < simd::float_4::zero();

  214. 				simd::float_4 delta_eq_0 = ~(delta_lt_0|delta_gt_0);

  215. 

  216. 				simd::float_4 rateCV = ifelse(delta_gt_0, riseCV[c/4], simd::float_4::zero());

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

  218. 				rateCV = clamp(rateCV, simd::float_4::zero(), simd::float_4(1.0f));

  219. 

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

  221. 

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

  223. 

  224. 				simd::float_4 rising  = (in[c/4] - out[part][c/4]) > simd::float_4( 1e-3);

  225. 				simd::float_4 falling = (in[c/4] - out[part][c/4]) < simd::float_4(-1e-3);

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

  227. 

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

  229. 

  230. 				gate[part][c/4] = ifelse( simd::andnot(rising, delta_gt_0),                 simd::float_4::zero(), gate[part][c/4]);

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

  232. 				gate[part][c/4] = ifelse( delta_eq_0,                                       simd::float_4::zero(), gate[part][c/4] );

  233. 

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

  235. 

  236. 				simd::float_4 out_rising  = ifelse(rising,  simd::float_4(10.0f), simd::float_4::zero() );

  237. 				simd::float_4 out_falling = ifelse(falling, simd::float_4(10.0f), simd::float_4::zero() );

  238. 

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

  240. 				simd::float_4 out_EOC = ifelse(pulse, simd::float_4(10.f), simd::float_4::zero() );

  241. 

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

  243. 

  244. 				out_rising.store( outputs[RISING_A_OUTPUT+part].getVoltages(c));

  245. 				out_falling.store(outputs[FALLING_A_OUTPUT+part].getVoltages(c));

  246. 				out_EOC.store(outputs[EOC_A_OUTPUT+part].getVoltages(c));

  247. 

  248. 

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

  250. 

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

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

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

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

  255. 			} else {

  256. 				lights[RISING_A_LIGHT + part].setSmoothBrightness(outputs[RISING_A_OUTPUT+part].getVoltageSum()/10.f, args.sampleTime);

  257. 				lights[FALLING_A_LIGHT + part].setSmoothBrightness(outputs[FALLING_A_OUTPUT+part].getVoltageSum()/10.f, args.sampleTime);

  258. 				lights[OUT_A_LIGHT + part].setSmoothBrightness(outputs[OUT_A_OUTPUT].getVoltageSum() / 10.0, args.sampleTime);

  259. 

  260. 			}

  261. 

  262. 			// Integrator

  263. 

  264. 			// bool rising = false;

  265. 			// bool falling = false;

  266. 

  267. 			/* 

  268. 			if (delta > 0) {

  269. 				// Rise

  270. 				float riseCv = params[RISE_A_PARAM + c].getValue() - inputs[EXP_CV_A_INPUT + c].getVoltage() / 10.0 + inputs[RISE_CV_A_INPUT + c].getVoltage() / 10.0;

  271. 				riseCv = clamp(riseCv, 0.0f, 1.0f);

  272. 				float rise = minTime * std::pow(2.0, riseCv * 10.0);

  273. 				out[c] += shapeDelta(delta, rise, shape) * args.sampleTime;

  274. 				rising = (in - out[c] > 1e-3);

  275. 				if (!rising) {

  276. 					gate[c] = false;

  277. 				}

  278. 			}

  279. 			else if (delta < 0) {

  280. 				// Fall

  281. 				float fallCv = params[FALL_A_PARAM + c].getValue() - inputs[EXP_CV_A_INPUT + c].getVoltage() / 10.0 + inputs[FALL_CV_A_INPUT + c].getVoltage() / 10.0;

  282. 				fallCv = clamp(fallCv, 0.0f, 1.0f);

  283. 				float fall = minTime * std::pow(2.0, fallCv * 10.0);

  284. 				out[c] += shapeDelta(delta, fall, shape) * args.sampleTime;

  285. 				falling = (in - out[c] < -1e-3);

  286. 				if (!falling) {

  287. 					// End of cycle, check if we should turn the gate back on (cycle mode)

  288. 					endOfCyclePulse[c].trigger(1e-3);

  289. 					if (params[CYCLE_A_PARAM + c].getValue() * 10.0 + inputs[CYCLE_A_INPUT + c].getVoltage() >= 4.0) {

  290. 						gate[c] = true;

  291. 					}

  292. 				}

  293. 			}

  294. 			else {

  295. 				gate[c] = false;

  296. 			}

  297. 			

  298. 

  299. 			if (!rising && !falling) {

  300. 				out[c] = in;

  301. 			}

  302. 			*/

  303. 

  304. 			// outputs[RISING_A_OUTPUT + part].setVoltage((rising ? 10.0 : 0.0));

  305. 			// outputs[FALLING_A_OUTPUT + part].setVoltage((falling ? 10.0 : 0.0));

  306. 			// lights[RISING_A_LIGHT + part].setSmoothBrightness(rising ? 1.0 : 0.0, args.sampleTime);

  307. 			// lights[FALLING_A_LIGHT + part].setSmoothBrightness(falling ? 1.0 : 0.0, args.sampleTime);

  308. 			// outputs[EOC_A_OUTPUT + part].setVoltage((endOfCyclePulse[c].process(args.sampleTime) ? 10.0 : 0.0));

  309. 			// outputs[OUT_A_OUTPUT + part].setVoltage(out[c]);

  310. 			// lights[OUT_A_LIGHT + part].setSmoothBrightness(out[c] / 10.0, args.sampleTime);

  311. 

  312. 

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

  314. 

  315. 

  316. 

  317. 		// Logic

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

  319. 

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

  321. 

  322. 			simd::float_4 a = out[0][c/4];

  323. 			simd::float_4 b = out[1][c/4];

  324. 

  325. 			if (balance < 0.5)

  326. 				b *= 2.0 * balance;

  327. 			else if (balance > 0.5)

  328. 				a *= 2.0 * (1.0 - balance);

  329. 

  330. 			simd::float_4 comp    = ifelse( b>a, simd::float_4(10.0f), simd::float_4::zero() );

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

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

  333. 

  334. 			comp.store(outputs[COMPARATOR_OUTPUT].getVoltages(c));

  335. 			out_min.store(outputs[MIN_OUTPUT].getVoltages(c));

  336. 			out_max.store(outputs[MAX_OUTPUT].getVoltages(c));

  337. 

  338. 		}

  339. 		// Lights

  340. 		lights[COMPARATOR_LIGHT].setSmoothBrightness(outputs[COMPARATOR_OUTPUT].getVoltageSum() / 10.0, args.sampleTime);

  341. 		lights[MIN_LIGHT].setSmoothBrightness(outputs[MIN_OUTPUT].getVoltageSum() / 10.0, args.sampleTime);

  342. 		lights[MAX_LIGHT].setSmoothBrightness(outputs[MAX_OUTPUT].getVoltageSum() / 10.0, args.sampleTime);

  343. 

  344. 	} // end process()

  345. };

  346. 

  347. 

  348. 

  349. 

  350. struct RampageWidget : ModuleWidget {

  351. 	RampageWidget(Rampage *module) {

  352. 		setModule(module);

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

  354. 

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

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

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

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

  359. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  373. 

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

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

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

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

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

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

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

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

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

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

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

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

  386. 

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

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

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

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

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

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

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

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

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

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

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

  398. 

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

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

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

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

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

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

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

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

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

  408. 	}

  409. };

  410. 

  411. 

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