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.
112 Commits
7 Branches
39MB
Tree: 3b80c5cdd3
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3b80c5cdd3'
${ noResults }
Befaco/src/Percall.cpp

220 lines
9.3KB
Raw Blame History 

  1. #include "plugin.hpp"

  2. 

  3. using simd::float_4;

  4. 

  5. struct Percall : Module {

  6. 	enum ParamIds {

  7. 		ENUMS(VOL_PARAMS, 4),

  8. 		ENUMS(DECAY_PARAMS, 4),

  9. 		ENUMS(CHOKE_PARAMS, 2),

  10. 		NUM_PARAMS

  11. 	};

  12. 	enum InputIds {

  13. 		ENUMS(CH_INPUTS, 4),

  14. 		STRENGTH_INPUT,

  15. 		ENUMS(TRIG_INPUTS, 4),

  16. 		ENUMS(CV_INPUTS, 4),

  17. 		NUM_INPUTS

  18. 	};

  19. 	enum OutputIds {

  20. 		ENUMS(CH_OUTPUTS, 4),

  21. 		ENUMS(ENV_OUTPUTS, 4),

  22. 		NUM_OUTPUTS

  23. 	};

  24. 	enum LightIds {

  25. 		ENUMS(LEDS, 4),

  26. 		NUM_LIGHTS

  27. 	};

  28. 

  29. 	ADEnvelope envs[4];

  30. 

  31. 	float gains[4] = {};

  32. 

  33. 	dsp::SchmittTrigger trigger[4];

  34. 	dsp::ClockDivider cvDivider;

  35. 	dsp::ClockDivider lightDivider;

  36. 	const int LAST_CHANNEL_ID = 3;

  37. 

  38. 	const float attackTime = 1.5e-3;

  39. 	const float minDecayTime = 4.5e-3;

  40. 	const float maxDecayTime = 4.f;

  41. 

  42. 	Percall() {

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

  44. 		for (int i = 0; i < 4; i++) {

  45. 			configParam(VOL_PARAMS + i, 0.f, 1.f, 1.f, string::f("Channel %d level", i + 1), "%", 0, 100);

  46. 			configParam(DECAY_PARAMS + i, 0.f, 1.f, 0.f, string::f("Channel %d decay time", i + 1));

  47. 			envs[i].attackTime = attackTime;

  48. 			envs[i].attackShape = 0.5f;

  49. 			envs[i].decayShape = 2.0f;

  50. 		}

  51. 

  52. 		for (int i = 0; i < 2; i++) {			

  53. 			configParam(CHOKE_PARAMS + i, 0.f, 1.f, 0.f, string::f("Choke %d to %d", 2 * i + 1, 2 * i + 2));

  54. 		}

  55. 

  56. 		cvDivider.setDivision(16);

  57. 		lightDivider.setDivision(128);

  58. 	}

  59. 

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

  61. 

  62. 		float strength = 1.0f;

  63. 		if (inputs[STRENGTH_INPUT].isConnected()) {

  64. 			strength = std::sqrt(clamp(inputs[STRENGTH_INPUT].getVoltage() / 10.0f, 0.0f, 1.0f));

  65. 		}

  66. 

  67. 		// only calculate gains/decays every 16 samples

  68. 		if (cvDivider.process()) {

  69. 			for (int i = 0; i < 4; i++) {

  70. 				gains[i] = std::pow(params[VOL_PARAMS + i].getValue(), 2.f) * strength;

  71. 

  72. 				float fallCv = inputs[CV_INPUTS + i].getVoltage() * 0.05f + params[DECAY_PARAMS + i].getValue();

  73. 				envs[i].decayTime = rescale(std::pow(clamp(fallCv, 0.f, 1.0f), 2.f), 0.f, 1.f, minDecayTime, maxDecayTime);

  74. 			}

  75. 		}

  76. 

  77. 		float_4 mix[4] = {};

  78. 		int maxPolyphonyChannels = 1;

  79. 

  80. 		// Mixer channels

  81. 		for (int i = 0; i < 4; i++) {

  82. 

  83. 			if (trigger[i].process(rescale(inputs[TRIG_INPUTS + i].getVoltage(), 0.1f, 2.f, 0.f, 1.f))) {

  84. 				envs[i].trigger();

  85. 			}

  86. 			// if choke is enabled, and current channel is odd and left channel is in attack

  87. 			if ((i % 2) && params[CHOKE_PARAMS + i / 2].getValue() && envs[i - 1].stage == ADEnvelope::STAGE_ATTACK) {

  88. 				// TODO: is there a more graceful way to choke, e.g. rapid envelope?

  89. 				// TODO: this will just silence it instantly, maybe switch to STAGE_DECAY and modify fall time

  90. 				envs[i].stage = ADEnvelope::STAGE_OFF;

  91. 			}

  92. 

  93. 			envs[i].process(args.sampleTime);

  94. 

  95. 			int polyphonyChannels = 1;

  96. 			float_4 in[4] = {};

  97. 			bool inputIsConnected = inputs[CH_INPUTS + i].isConnected();

  98. 			bool inputIsNormed = !inputIsConnected && (i % 2) && inputs[CH_INPUTS + i - 1].isConnected();

  99. 			if ((inputIsConnected || inputIsNormed)) {

  100. 				int channelToReadFrom = inputIsNormed ? CH_INPUTS + i - 1 : CH_INPUTS + i;

  101. 				polyphonyChannels = inputs[channelToReadFrom].getChannels();

  102. 

  103. 				// an input only counts towards the main output polyphony count if it's not taken out of the mix

  104. 				// (i.e. an output is patched in). the final input should always count towards polyphony count.

  105. 				if (i == CH_INPUTS_LAST || !outputs[CH_OUTPUTS + i].isConnected()) {

  106. 					maxPolyphonyChannels = std::max(maxPolyphonyChannels, polyphonyChannels);

  107. 				}

  108. 

  109. 				// only process input audio if envelope is active

  110. 				if (envs[i].stage != ADEnvelope::STAGE_OFF) {

  111. 					float gain = gains[i] * envs[i].env;

  112. 					for (int c = 0; c < polyphonyChannels; c += 4) {

  113. 						in[c / 4] = inputs[channelToReadFrom].getVoltageSimd<float_4>(c) * gain;

  114. 					}

  115. 				}

  116. 			}

  117. 

  118. 			if (i != LAST_CHANNEL_ID) {

  119. 				// if connected, output via the jack (and don't add to mix)

  120. 				if (outputs[CH_OUTPUTS + i].isConnected()) {

  121. 					outputs[CH_OUTPUTS + i].setChannels(polyphonyChannels);

  122. 					for (int c = 0; c < polyphonyChannels; c += 4) {

  123. 						outputs[CH_OUTPUTS + i].setVoltageSimd(in[c / 4], c);

  124. 					}

  125. 				}

  126. 				else {

  127. 					// else add to mix

  128. 					for (int c = 0; c < polyphonyChannels; c += 4) {

  129. 						mix[c / 4] += in[c / 4];

  130. 					}

  131. 				}

  132. 			}

  133. 			// otherwise if it is the final channel and it's wired in

  134. 			else if (outputs[CH_OUTPUTS + i].isConnected()) {

  135. 

  136. 				outputs[CH_OUTPUTS + i].setChannels(maxPolyphonyChannels);

  137. 

  138. 				// last channel must always go into mix

  139. 				for (int c = 0; c < polyphonyChannels; c += 4) {

  140. 					mix[c / 4] += in[c / 4];

  141. 				}

  142. 

  143. 				for (int c = 0; c < maxPolyphonyChannels; c += 4) {

  144. 					outputs[CH_OUTPUTS + i].setVoltageSimd(mix[c / 4], c);

  145. 				}

  146. 			}

  147. 

  148. 			// set env output

  149. 			if (outputs[ENV_OUTPUTS + i].isConnected()) {

  150. 				outputs[ENV_OUTPUTS + i].setVoltage(10.f * strength * envs[i].env);

  151. 			}

  152. 		}

  153. 

  154. 		if (lightDivider.process()) {

  155. 			for (int i = 0; i < 4; i++) {

  156. 				lights[LEDS + i].setBrightness(envs[i].env);

  157. 			}

  158. 		}

  159. 

  160. 	}

  161. };

  162. 

  163. 

  164. struct PercallWidget : ModuleWidget {

  165. 	PercallWidget(Percall* module) {

  166. 		setModule(module);

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

  168. 

  169. 		addChild(createWidget<Knurlie>(Vec(RACK_GRID_WIDTH, 0)));

  170. 		addChild(createWidget<Knurlie>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, 0)));

  171. 		addChild(createWidget<Knurlie>(Vec(RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

  172. 		addChild(createWidget<Knurlie>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

  173. 

  174. 		addParam(createParamCentered<BefacoTinyKnob>(mm2px(Vec(8.048, 41.265)), module, Percall::VOL_PARAMS + 0));

  175. 		addParam(createParamCentered<BefacoTinyKnob>(mm2px(Vec(22.879, 41.265)), module, Percall::VOL_PARAMS + 1));

  176. 		addParam(createParamCentered<BefacoTinyKnob>(mm2px(Vec(37.709, 41.265)), module, Percall::VOL_PARAMS + 2));

  177. 		addParam(createParamCentered<BefacoTinyKnob>(mm2px(Vec(52.54, 41.265)), module, Percall::VOL_PARAMS + 3));

  178. 		addParam(createParam<BefacoSlidePot>(mm2px(Vec(5.385, 53.912)), module, Percall::DECAY_PARAMS + 0));

  179. 		addParam(createParam<BefacoSlidePot>(mm2px(Vec(20.292, 53.912)), module, Percall::DECAY_PARAMS + 1));

  180. 		addParam(createParam<BefacoSlidePot>(mm2px(Vec(35.173, 53.912)), module, Percall::DECAY_PARAMS + 2));

  181. 		addParam(createParam<BefacoSlidePot>(mm2px(Vec(49.987, 53.912)), module, Percall::DECAY_PARAMS + 3));

  182. 

  183. 		addParam(createParam<CKSS>(mm2px(Vec(13.365, 58.672)), module, Percall::CHOKE_PARAMS + 0));

  184. 		addParam(createParam<CKSS>(mm2px(Vec(42.993, 58.672)), module, Percall::CHOKE_PARAMS + 1));

  185. 

  186. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(7.15, 12.905)), module, Percall::CH_INPUTS + 0));

  187. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(20.298, 12.905)), module, Percall::CH_INPUTS + 1));

  188. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(40.266, 12.905)), module, Percall::CH_INPUTS + 2));

  189. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(53.437, 12.905)), module, Percall::CH_INPUTS + 3));

  190. 

  191. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(30.282, 18.221)), module, Percall::STRENGTH_INPUT));

  192. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(7.15, 24.827)), module, Percall::TRIG_INPUTS + 0));

  193. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(18.488, 23.941)), module, Percall::TRIG_INPUTS + 1));

  194. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(42.171, 23.95)), module, Percall::TRIG_INPUTS + 2));

  195. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(53.437, 24.827)), module, Percall::TRIG_INPUTS + 3));

  196. 

  197. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(5.037, 101.844)), module, Percall::CV_INPUTS + 0));

  198. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(15.159, 101.844)), module, Percall::CV_INPUTS + 1));

  199. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(25.28, 101.844)), module, Percall::CV_INPUTS + 2));

  200. 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(35.402, 101.844)), module, Percall::CV_INPUTS + 3));

  201. 

  202. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(45.524, 101.844)), module, Percall::CH_OUTPUTS + 0));

  203. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(55.645, 101.844)), module, Percall::CH_OUTPUTS + 1));

  204. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(45.524, 113.766)), module, Percall::CH_OUTPUTS + 2));

  205. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(55.645, 113.766)), module, Percall::CH_OUTPUTS + 3));

  206. 

  207. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(5.037, 113.766)), module, Percall::ENV_OUTPUTS + 0));

  208. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(15.159, 113.766)), module, Percall::ENV_OUTPUTS + 1));

  209. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(25.28, 113.766)), module, Percall::ENV_OUTPUTS + 2));

  210. 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(35.402, 113.766)), module, Percall::ENV_OUTPUTS + 3));

  211. 

  212. 		addChild(createLightCentered<SmallLight<RedLight>>(mm2px(Vec(8.107, 49.221)), module, Percall::LEDS + 0));

  213. 		addChild(createLightCentered<SmallLight<RedLight>>(mm2px(Vec(22.934, 49.221)), module, Percall::LEDS + 1));

  214. 		addChild(createLightCentered<SmallLight<RedLight>>(mm2px(Vec(37.762, 49.221)), module, Percall::LEDS + 2));

  215. 		addChild(createLightCentered<SmallLight<RedLight>>(mm2px(Vec(52.589, 49.221)), module, Percall::LEDS + 3));

  216. 	}

  217. };

  218. 

  219. 

  220. Model* modelPercall = createModel<Percall, PercallWidget>("Percall");