VCVRack
/
Rack
mirror of https://github.com/VCVRack/Rack.git
1
0
Fork 0
Code Issues 0 Releases 43 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.
1081 Commits
4 Branches
544MB
Tree: 3319c826e3
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3319c826e3'
${ noResults }
Rack/plugins/community/repos/TheXOR/src/burst.cpp

239 lines
7.2KB
Raw Blame History 

  1. #include "common.hpp"

  2. #include "burst.hpp"

  3. 

  4. namespace rack_plugin_TheXOR {

  5. 

  6. void Burst::on_loaded()

  7. {

  8. 	load();

  9. }

  10. 

  11. void Burst::load()

  12. {

  13. 	trigger_pending = false;

  14. 	all_off();

  15. }

  16. 

  17. void Burst::all_off()

  18. {

  19. 	for(int k = 0; k < NUM_BURST_PORTS; k++)

  20. 		port(k, false);

  21. 	active = false;

  22. }

  23. 

  24. void Burst::step()

  25. {

  26. 	if(resetTrigger.process(inputs[RESET].value))

  27. 	{

  28. 		reset();

  29. 	} else

  30. 	{

  31. 		if(!active && !trigger_pending)

  32. 		{

  33. 			float tv = inputs[TRIGGER_THRESH_IN].active && inputs[TRIGGER_THRESH_IN].value > params[TRIG_THRESH].value ? 1.0 : 0.0;

  34. 			trigger_pending = trigger.process(params[TRIGGER].value + tv);

  35. 		}

  36. 

  37. 		int clk = clock.process(inputs[CLOCK_IN].value); // 1=rise, -1=fall

  38. 

  39. 		if(clk == 1)

  40. 		{

  41. 			if(!active && trigger_pending)

  42. 			{

  43. 				prepare_step();

  44. 			}

  45. 

  46. 			if(active)

  47. 				next_step();

  48. 		} else if(active && clk == -1)

  49. 			end_step();

  50. 	}

  51. }

  52. 

  53. void Burst::prepare_step()

  54. {

  55. 	activating_params.first_cycle = true;

  56. 	activating_params.cycle_counter = activating_params.out_span = 0;

  57. 	activating_params.max_span = getInt(OUT_SPAN, OUT_SPAN_IN, 1, NUM_BURST_PORTS);

  58. 	activating_params.mode = (enum Burst::MODE)int(roundf(params[MODE].value));

  59. 	activating_params.invert_mode = roundf(params[MODE_INVERT].value) > 0.5;

  60. 	activating_params.retrogade = false;	

  61. 	activating_params.max_cycle = getInt(EVENT_COUNT, EVENT_COUNT_IN, 0, 23) + 1;

  62. 	trigger_pending = false;

  63. 	active = true;

  64. }

  65. 

  66. void Burst::end_step()

  67. {

  68. 	if(activating_params.cycle_counter >= activating_params.max_cycle)

  69. 	{

  70. 		all_off();	// ciclo terminato

  71. 	} else

  72. 	{

  73. 		switch(activating_params.mode)

  74. 		{

  75. 			case Burst::RAND:

  76. 			{

  77. 				port(activating_params.out_span, false);

  78. 			}

  79. 			break;

  80. 

  81. 			case Burst::PEND:

  82. 			case Burst::FWD:

  83. 			{				

  84. 				if(!activating_params.invert_mode)

  85. 				{

  86. 					port(activating_params.out_span, false);

  87. 				}					

  88. 			}

  89. 			break;

  90. 		}

  91. 	}

  92. }

  93. 

  94. void Burst::next_step()

  95. {

  96. 	switch(activating_params.mode)

  97. 	{

  98. 		case Burst::RAND:

  99. 		{

  100. 			activating_params.out_span = int(rescale(randomUniform(), 0.0, 1.0, 0.0, activating_params.max_span));

  101. 			port(activating_params.out_span, true);

  102. 			activating_params.cycle_counter++;

  103. 		}

  104. 		break;

  105. 

  106. 		case Burst::FWD:

  107. 		{

  108. 			if(activating_params.first_cycle)

  109. 				activating_params.first_cycle = false;

  110. 			else

  111. 			{

  112. 				if(++activating_params.out_span >= activating_params.max_span)

  113. 				{

  114. 					activating_params.out_span = 0;

  115. 					activating_params.cycle_counter++;

  116. 				}

  117. 			}

  118. 			if(activating_params.cycle_counter < activating_params.max_cycle)

  119. 			{

  120. 				if(activating_params.invert_mode)

  121. 					invert_port(activating_params.out_span);

  122. 				else

  123. 				{

  124. 					port(activating_params.out_span, true);

  125. 				}

  126. 			}

  127. 		}

  128. 		break;

  129. 			

  130. 		case Burst::PEND:

  131. 		{

  132. 			if(activating_params.first_cycle)

  133. 				activating_params.first_cycle = false;

  134. 			else

  135. 			{

  136. 				if(activating_params.retrogade)

  137. 				{

  138. 					if(--activating_params.out_span < 0)

  139. 					{

  140. 						if(activating_params.max_span > 0)

  141. 							activating_params.out_span = activating_params.invert_mode ? 0 : 1;

  142. 						else

  143. 							activating_params.out_span = 0;

  144. 						activating_params.retrogade = false;

  145. 						activating_params.cycle_counter++;

  146. 					}

  147. 				} else

  148. 				{

  149. 					if(++activating_params.out_span >= activating_params.max_span)

  150. 					{

  151. 						if(activating_params.max_span > 1)

  152. 							activating_params.out_span = activating_params.invert_mode ? activating_params.out_span-1 : activating_params.out_span - 2;

  153. 						else

  154. 							activating_params.out_span = 0;

  155. 						activating_params.retrogade = true;

  156. 						activating_params.cycle_counter++;

  157. 					}

  158. 				}

  159. 			}

  160. 			if(activating_params.cycle_counter < activating_params.max_cycle)

  161. 			{

  162. 				if(activating_params.invert_mode)

  163. 					invert_port(activating_params.out_span);

  164. 				else

  165. 					port(activating_params.out_span, true);

  166. 			}

  167. 		}

  168. 		break;

  169. 	}

  170. }

  171. 

  172. int Burst::getInt(ParamIds p_id, InputIds i_id, float minValue, float maxValue)

  173. {

  174. 	float offs = inputs[i_id].active ? rescale(inputs[i_id].value, 0.0, 5.0, minValue, maxValue) : 0.0;

  175. 	return (int)clamp(offs + params[p_id].value, minValue, maxValue);

  176. }

  177. 

  178. BurstWidget::BurstWidget(Burst *module) : SequencerWidget(module)

  179. {

  180. 	box.size = Vec(16 * RACK_GRID_WIDTH, RACK_GRID_HEIGHT);

  181. 	{

  182. 		SVGPanel *panel = new SVGPanel();

  183. 		panel->box.size = box.size;

  184. 		panel->setBackground(SVG::load(assetPlugin(plugin, "res/modules/Burst.svg")));		

  185. 		addChild(panel);

  186. 	}

  187. 	addChild(Widget::create<ScrewBlack>(Vec(RACK_GRID_WIDTH, 0)));

  188. 	addChild(Widget::create<ScrewBlack>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, 0)));

  189. 	addChild(Widget::create<ScrewBlack>(Vec(RACK_GRID_WIDTH, box.size.y - RACK_GRID_WIDTH)));

  190. 	addChild(Widget::create<ScrewBlack>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, box.size.y - RACK_GRID_WIDTH)));

  191. 	float lft_x = mm2px(3.428);

  192. 

  193. 	addInput(Port::create<PJ301RPort>(Vec(lft_x, yncscape(108.765, 8.255)), Port::INPUT, module, Burst::CLOCK_IN));

  194. 	addParam(ParamWidget::create<CKSSThreeFix>(Vec(mm2px(31.624), yncscape(105.749, 10.0)), module, Burst::MODE, 0.0, 2.0, 0.0));

  195. 	addParam(ParamWidget::create<CKSSFix>(Vec(mm2px(71.875), yncscape(107.990, 5.46)), module, Burst::MODE_INVERT, 0.0, 1.0, 0.0));

  196. 	

  197. 	addInput(Port::create<PJ301BPort>(Vec(lft_x, yncscape(74.386, 8.255)), Port::INPUT, module, Burst::OUT_SPAN_IN));

  198. 	ParamWidget *pwdg = ParamWidget::create<Davies1900hFixWhiteKnob>(Vec(mm2px(22.644), yncscape(73.751, 9.525)), module, Burst::OUT_SPAN, 1.0, NUM_BURST_PORTS, 1.0);

  199. 	((Davies1900hKnob *)pwdg)->snap = true;

  200. 	addParam(pwdg);

  201. 	pwdg = ParamWidget::create<Davies1900hFixWhiteKnob>(Vec(mm2px(49.111), yncscape(73.751, 9.525)), module, Burst::EVENT_COUNT, 0.0, 23.0, 0.0);

  202. 	((Davies1900hKnob *)pwdg)->snap = true;

  203. 	addParam(pwdg);

  204. 	addInput(Port::create<PJ301BPort>(Vec(mm2px(69.597), yncscape(74.386, 8.255)), Port::INPUT, module, Burst::EVENT_COUNT_IN));

  205. 

  206. 	addInput(Port::create<PJ301BPort>(Vec(lft_x, yncscape(43.036, 8.255)), Port::INPUT, module, Burst::TRIGGER_THRESH_IN));

  207. 	addParam(ParamWidget::create<Davies1900hFixRedKnob>(Vec(mm2px(16.027), yncscape(42.401, 9.525)), module, Burst::TRIG_THRESH, LVL_OFF, LVL_ON, LVL_OFF));

  208. 	addInput(Port::create<PJ301YPort>(Vec(mm2px(56.363), yncscape(43.036, 8.255)), Port::INPUT, module, Burst::RESET));

  209. 	addParam(ParamWidget::create<BefacoPushBig>(Vec(mm2px(69.224), yncscape(42.664, 8.999)), module, Burst::TRIGGER, 0.0, 1.0, 0.0));

  210. 

  211. 	float ysup_port = yncscape(17.532, 8.255);

  212. 	float yinf_port = yncscape(4.832, 8.255);

  213. 	float ysup_led = yncscape(19.070, 5.179);

  214. 	float yinf_led = yncscape(6.370, 5.179);

  215. 	float x_ports[NUM_BURST_PORTS] = {3.428, 16.662, 29.895, 43.129, 56.363, 69.597};

  216. 	float x_leds[NUM_BURST_PORTS] = {4.966, 18.200, 31.434, 44.667, 57.901, 71.135};

  217. 

  218. 	for(int k = 0; k < NUM_BURST_PORTS; k++)

  219. 	{

  220. 		if(k < NUM_BURST_PORTS / 2)

  221. 		{

  222. 			addOutput(Port::create<PJ301WPort>(Vec(mm2px(x_ports[k]), ysup_port), Port::OUTPUT, module, Burst::OUT_1+k));

  223. 			addChild(ModuleLightWidget::create<LargeLight<RedLight>>(Vec(mm2px(x_leds[k]), yinf_led), module, Burst::LEDOUT_1 + k));

  224. 		} else

  225. 		{

  226. 			addOutput(Port::create<PJ301WPort>(Vec(mm2px(x_ports[k]), yinf_port), Port::OUTPUT, module, Burst::OUT_1 + k));

  227. 			addChild(ModuleLightWidget::create<LargeLight<RedLight>>(Vec(mm2px(x_leds[k]), ysup_led), module, Burst::LEDOUT_1 + k));

  228. 		}

  229. 	}

  230. }

  231. 

  232. } // namespace rack_plugin_TheXOR

  233. 

  234. using namespace rack_plugin_TheXOR;

  235. 

  236. RACK_PLUGIN_MODEL_INIT(TheXOR, Burst) {

  237. 	return Model::create<Burst, BurstWidget>("TheXOR", "Burst", "Burst", SEQUENCER_TAG);

  238. }