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.
62 Commits
7 Branches
39MB
Tree: 0cb2d2e6bd
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0cb2d2e6bd'
${ noResults }
Befaco/src/Rampage.cpp

444 lines
17KB
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. 		ENUMS(COMPARATOR_LIGHT, 3),

  68. 		ENUMS(MIN_LIGHT, 3),

  69. 		ENUMS(MAX_LIGHT, 3),

  70. 		ENUMS(OUT_A_LIGHT, 3),

  71. 		ENUMS(OUT_B_LIGHT, 3),

  72. 		ENUMS(RISING_A_LIGHT, 3),

  73. 		ENUMS(RISING_B_LIGHT, 3),

  74. 		ENUMS(FALLING_A_LIGHT, 3),

  75. 		ENUMS(FALLING_B_LIGHT, 3),

  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. 			

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

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

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

  125. 			channels[part] = MAX(1, channels[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. 		outputs[COMPARATOR_OUTPUT].setChannels(channels_max);

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

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

  137. 

  138. 		// loop over two parts of Rampage:

  139. 

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

  141. 

  142. 			simd::float_4 in[4];

  143. 			simd::float_4 in_trig[4];

  144. 			simd::float_4 expCV[4];

  145. 			simd::float_4 riseCV[4];

  146. 			simd::float_4 fallCV[4];

  147. 			simd::float_4 cycle[4];

  148. 

  149. 			// get parameters:

  150. 

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

  152. 			float minTime;

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

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

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

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

  157. 			}

  158. 

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

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

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

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

  163. 

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

  165. 				riseCV[c/4] = param_rise;

  166. 				fallCV[c/4] = param_fall;

  167. 				cycle[c/4] = param_cycle;

  168. 				in_trig[c/4] = param_trig;

  169. 

  170. 			}

  171. 

  172. 

  173. 			// read inputs:

  174. 

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

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

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

  178. 			} else {

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

  180. 			}

  181. 

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

  183. 				add_input(inputs[TRIGG_A_INPUT + part], in_trig, channels_trig[part]);

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

  185. 			} 	

  186. 

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

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

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

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

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

  192. 				}

  193. 			}

  194. 

  195. 			add_input(inputs[RISE_CV_A_INPUT + part], riseCV, channels[part]);

  196. 			add_input(inputs[FALL_CV_A_INPUT + part], fallCV, channels[part]);	

  197. 			add_input(inputs[CYCLE_A_INPUT+part], cycle, channels[part]);

  198. 			channelMask.apply(cycle, channels[part]); // check whether this is necessary

  199. 

  200. 			// start processing:

  201. 			

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

  203. 

  204. 				// process SchmittTriggers

  205. 

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

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

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

  209. 

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

  211. 

  212. 				// rise / fall branching

  213. 

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

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

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

  217. 

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

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

  220. 				rateCV = clamp(rateCV, simd::float_4::zero(), simd::float_4(10.0f));

  221. 

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

  223. 

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

  225. 

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

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

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

  229. 

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

  231. 

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

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

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

  235. 

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

  237. 

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

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

  240. 

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

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

  243. 

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

  245. 

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

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

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

  249. 

  250. 

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

  252. 

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

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

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

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

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

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

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

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

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

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

  263. 			} else {

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

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

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

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

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

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

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

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

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

  273. 			}

  274. 

  275. 			// Integrator

  276. 

  277. 			// bool rising = false;

  278. 			// bool falling = false;

  279. 

  280. 			/* 

  281. 			if (delta > 0) {

  282. 				// Rise

  283. 				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;

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

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

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

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

  288. 				if (!rising) {

  289. 					gate[c] = false;

  290. 				}

  291. 			}

  292. 			else if (delta < 0) {

  293. 				// Fall

  294. 				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;

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

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

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

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

  299. 				if (!falling) {

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

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

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

  303. 						gate[c] = true;

  304. 					}

  305. 				}

  306. 			}

  307. 			else {

  308. 				gate[c] = false;

  309. 			}

  310. 			

  311. 

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

  313. 				out[c] = in;

  314. 			}

  315. 			*/

  316. 

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

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

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

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

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

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

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

  324. 

  325. 

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

  327. 

  328. 

  329. 

  330. 		// Logic

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

  332. 

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

  334. 

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

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

  337. 

  338. 			if (balance < 0.5)

  339. 				b *= 2.0f * balance;

  340. 			else if (balance > 0.5)

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

  342. 

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

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

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

  346. 

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

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

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

  350. 

  351. 		}

  352. 		// Lights

  353. 		if(channels_max==1) {

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

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

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

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

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

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

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

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

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

  363. 		} else {

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

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

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

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

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

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

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

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

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

  373. 		}

  374. 

  375. 	} // end process()

  376. };

  377. 

  378. 

  379. 

  380. 

  381. struct RampageWidget : ModuleWidget {

  382. 	RampageWidget(Rampage *module) {

  383. 		setModule(module);

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

  385. 

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

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

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

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

  390. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  404. 

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

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

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

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

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

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

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

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

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

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

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

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

  417. 

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

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

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

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

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

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

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

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

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

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

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

  429. 

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

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

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

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

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

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

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

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

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

  439. 	}

  440. };

  441. 

  442. 

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