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.
984 Commits
4 Branches
541MB
Tree: 0a41bb286f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0a41bb286f'
${ noResults }
Rack/plugins/community/repos/FrozenWasteland/src/PortlandWeather.cpp

956 lines
37KB
Raw Blame History 

  1. #include "FrozenWasteland.hpp"

  2. #include "dsp/samplerate.hpp"

  3. #include "dsp/digital.hpp"

  4. #include "dsp/filter.hpp"

  5. #include "ringbuffer.hpp"

  6. #include "StateVariableFilter.h"

  7. #include "clouds/dsp/frame.h"

  8. #include "clouds/dsp/fx/pitch_shifter.h"

  9. #include <iostream>

  10. 

  11. #define HISTORY_SIZE (1<<22)

  12. #define MAX_GRAIN_SIZE (1<<16)

  13. #define NUM_TAPS 16

  14. #define MAX_GRAINS 4

  15. #define CHANNELS 2

  16. #define DIVISIONS 21

  17. #define NUM_GROOVES 16

  18. 

  19. namespace rack_plugin_FrozenWasteland {

  20. 

  21. struct PortlandWeather : Module {

  22. 	typedef float T;

  23. 

  24. 	enum ParamIds {

  25. 		CLOCK_DIV_PARAM,

  26. 		TIME_PARAM,

  27. 		GRID_PARAM,

  28. 		GROOVE_TYPE_PARAM,

  29. 		GROOVE_AMOUNT_PARAM,

  30. 		GRAIN_QUANTITY_PARAM,

  31. 		GRAIN_SIZE_PARAM,

  32. 		FEEDBACK_PARAM,

  33. 		FEEDBACK_TAP_L_PARAM,

  34. 		FEEDBACK_TAP_R_PARAM,

  35. 		FEEDBACK_L_SLIP_PARAM,

  36. 		FEEDBACK_R_SLIP_PARAM,

  37. 		FEEDBACK_TONE_PARAM,

  38. 		FEEDBACK_L_PITCH_SHIFT_PARAM,

  39. 		FEEDBACK_R_PITCH_SHIFT_PARAM,

  40. 		FEEDBACK_L_DETUNE_PARAM,

  41. 		FEEDBACK_R_DETUNE_PARAM,		

  42. 		PING_PONG_PARAM,

  43. 		REVERSE_PARAM,

  44. 		MIX_PARAM,

  45. 		TAP_MUTE_PARAM,

  46. 		TAP_STACKED_PARAM = TAP_MUTE_PARAM+NUM_TAPS,

  47. 		TAP_MIX_PARAM = TAP_STACKED_PARAM+NUM_TAPS,

  48. 		TAP_PAN_PARAM = TAP_MIX_PARAM+NUM_TAPS,

  49. 		TAP_FILTER_TYPE_PARAM = TAP_PAN_PARAM+NUM_TAPS,

  50. 		TAP_FC_PARAM = TAP_FILTER_TYPE_PARAM+NUM_TAPS,

  51. 		TAP_Q_PARAM = TAP_FC_PARAM+NUM_TAPS,

  52. 		TAP_PITCH_SHIFT_PARAM = TAP_Q_PARAM+NUM_TAPS,

  53. 		TAP_DETUNE_PARAM = TAP_PITCH_SHIFT_PARAM+NUM_TAPS,

  54. 		CLEAR_BUFFER_PARAM = TAP_DETUNE_PARAM+NUM_TAPS,

  55. 		NUM_PARAMS

  56. 	};

  57. 	enum InputIds {

  58. 		CLOCK_INPUT,

  59. 		CLOCK_DIVISION_CV_INPUT,

  60. 		TIME_CV_INPUT,

  61. 		EXTERNAL_DELAY_TIME_INPUT,

  62. 		GRID_CV_INPUT,

  63. 		GROOVE_TYPE_CV_INPUT,

  64. 		GROOVE_AMOUNT_CV_INPUT,

  65. 		FEEDBACK_INPUT,

  66. 		FEEDBACK_TAP_L_INPUT,

  67. 		FEEDBACK_TAP_R_INPUT,

  68. 		FEEDBACK_TONE_INPUT,

  69. 		FEEDBACK_L_SLIP_CV_INPUT,

  70. 		FEEDBACK_R_SLIP_CV_INPUT,

  71. 		FEEDBACK_L_PITCH_SHIFT_CV_INPUT,

  72. 		FEEDBACK_R_PITCH_SHIFT_CV_INPUT,

  73. 		FEEDBACK_L_DETUNE_CV_INPUT,

  74. 		FEEDBACK_R_DETUNE_CV_INPUT,

  75. 		FEEDBACK_L_RETURN,

  76. 		FEEDBACK_R_RETURN,

  77. 		PING_PONG_INPUT,

  78. 		REVERSE_INPUT,

  79. 		MIX_INPUT,

  80. 		TAP_MUTE_CV_INPUT,

  81. 		TAP_STACK_CV_INPUT = TAP_MUTE_CV_INPUT + NUM_TAPS,

  82. 		TAP_MIX_CV_INPUT = TAP_STACK_CV_INPUT + NUM_TAPS,

  83. 		TAP_PAN_CV_INPUT = TAP_MIX_CV_INPUT + NUM_TAPS,

  84. 		TAP_FC_CV_INPUT = TAP_PAN_CV_INPUT + NUM_TAPS,

  85. 		TAP_Q_CV_INPUT = TAP_FC_CV_INPUT + NUM_TAPS,

  86. 		TAP_PITCH_SHIFT_CV_INPUT = TAP_Q_CV_INPUT + NUM_TAPS,

  87. 		TAP_DETUNE_CV_INPUT = TAP_PITCH_SHIFT_CV_INPUT + NUM_TAPS,

  88. 		IN_L_INPUT = TAP_DETUNE_CV_INPUT+NUM_TAPS,

  89. 		IN_R_INPUT,

  90. 		NUM_INPUTS

  91. 	};

  92. 	enum OutputIds {

  93. 		OUT_L_OUTPUT,

  94. 		OUT_R_OUTPUT,

  95. 		FEEDBACK_L_OUTPUT,

  96. 		FEEDBACK_R_OUTPUT,

  97. 		NUM_OUTPUTS

  98. 	};

  99. 	enum LightIds {

  100. 		PING_PONG_LIGHT,

  101. 		REVERSE_LIGHT,

  102. 		TAP_MUTED_LIGHT,

  103. 		TAP_STACKED_LIGHT = TAP_MUTED_LIGHT+NUM_TAPS,

  104. 		FREQ_LIGHT = TAP_STACKED_LIGHT+NUM_TAPS,

  105. 		NUM_LIGHTS

  106. 	};

  107. 	enum FilterModes {

  108. 		FILTER_NONE,

  109. 		FILTER_LOWPASS,

  110. 		FILTER_HIGHPASS,

  111. 		FILTER_BANDPASS,

  112. 		FILTER_NOTCH

  113. 	};

  114. 

  115. 	struct LowFrequencyOscillator {

  116. 	float phase = 0.0;

  117. 	float freq = 1.0;

  118. 	bool invert = false;

  119. 

  120. 	//void setFrequency(float frequency) {

  121. 	//	freq = frequency;

  122. 	//}

  123. 

  124. 	void hardReset()

  125. 	{

  126. 		phase = 0.0;

  127. 	}

  128. 

  129. 	void reset()

  130. 	{

  131. 		phase -= 1.0;

  132. 	}

  133. 

  134. 

  135. 	void step(float dt) {

  136. 		float deltaPhase = fminf(freq * dt, 0.5);

  137. 		phase += deltaPhase;

  138. 		//if (phase >= 1.0)

  139. 		//	phase -= 1.0;

  140. 	}

  141. 	float sin() {

  142. 		return sinf(2*M_PI * phase) * (invert ? -1.0 : 1.0);

  143. 	}

  144. 	float progress() {

  145. 		return phase;

  146. 	}

  147. };

  148. 

  149. 	const char* grooveNames[NUM_GROOVES] = {"Straight","Swing","Hard Swing","Reverse Swing","Alternate Swing","Accelerando","Ritardando","Waltz Time","Half Swing","Roller Coaster","Quintuple","Random 1","Random 2","Random 3","Early Reflection","Late Reflection"};

  150. 	const float tapGroovePatterns[NUM_GROOVES][NUM_TAPS] = {

  151. 		{1.0f,2.0f,3.0f,4.0f,5.0f,6.0f,7.0f,8.0f,9.0f,10.0f,11.0f,12.0f,13.0f,14.0f,15.0f,16.0f}, // Straight time

  152. 		{1.25f,2.0f,3.25f,4.0f,5.25f,6.0f,7.25f,8.0f,9.25f,10.0f,11.25f,12.0f,13.25f,14.0f,15.25f,16.0f}, // Swing

  153. 		{1.75f,2.0f,3.75,4.0f,5.75f,6.0f,7.75f,8.0f,9.75f,10.0f,11.75f,12.0f,13.75f,14.0f,15.75f,16.0f}, // Hard Swing

  154. 		{0.75f,2.0f,2.75f,4.0f,4.75f,6.0f,6.75f,8.0f,8.75f,10.0f,10.75f,12.0f,12.75f,14.0f,14.75f,16.0f}, // Reverse Swing

  155. 		{1.25f,2.0f,3.0f,4.0f,5.25f,6.0f,7.0f,8.0f,9.25f,10.0f,11.0f,12.0f,13.25f,14.0f,15.0f,16.0f}, // Alternate Swing

  156. 		{3.0f,5.0f,7.0f,9.0f,10.0f,11.0f,12.0f,13.0f,13.5f,14.0f,14.5f,15.0f,15.25f,15.5f,15.75f,16.0f}, // Accelerando

  157. 		{0.25f,0.5f,0.75f,1.0f,1.5f,2.0f,2.5f,3.0f,4.0f,5.0f,6.0f,7.0f,9.0f,11.0f,13.0f,16.0f}, // Ritardando

  158. 		{1.25f,2.75f,3.25f,4.0f,5.25f,6.75f,7.25f,8.0f,9.25f,10.75f,11.25f,12.0f,13.25f,14.75f,15.25f,16.0f}, // Waltz Time

  159. 		{1.5f,2.0f,3.5f,4.0f,5.0f,6.0f,7.0f,8.0f,9.5f,10.0f,11.5f,12.0f,13.0f,14.0f,15.0f,16.0f}, // Half Swing

  160. 		{1.0f,2.0f,4.0f,5.0f,6.0f,8.0f,10.0f,12.0f,12.5f,13.0f,13.5f,14.0f,14.5f,15.0f,15.5f,16.0f}, // Roller Coaster

  161. 		{1.75f,2.5f,3.25f,4.0f,4.75f,6.5f,7.25f,8.0f,9.75f,10.5f,11.25f,12.0f,12.75f,14.5f,15.25f,16.0f}, // Quintuple

  162. 		{0.25f,0.75f,1.0f,1.25f,4.0f,5.5f,7.25f,7.5f,8.0f,8.25f,10.0f,11.0f,13.5f,15.0f,15.75f,16.0f}, // Uniform Random 1

  163. 		{0.25f,4.75f,5.25f,5.5f,7.0f,8.0f,8.5f,8.75f,9.0f,9.25f,11.75f,12.75f,13.0f,13.25f,14.75f,15.5f}, // Uniform Random 2

  164. 		{0.75f,2.0f,2.25f,5.75f,7.25f,7.5f,7.75f,8.5f,8.75f,12.5f,12.75f,13.0f,13.75f,14.0f,14.5f,16.0f}, // Uniform Random 3

  165. 		{0.25f,0.5f,1.0f,1.25f,1.75f,2.0f,2.5f,3.5f,4.25f,4.5f,4.75f,5.0f,6.25f,8.25f,11.0f,16.0f}, // Early Reflection

  166. 		{7.0f,7.25f,9.0f,9.25f,10.25f,12.5f,13.0f,13.75f,14.0f,15.0f,15.25f,15.5f,15.75f,16.0f,16.0f,16.0f} // Late Reflection

  167. 	};

  168. 

  169. 	const float minCutoff = 15.0;

  170. 	const float maxCutoff = 8400.0;

  171. 

  172. 	int tapGroovePattern = 0;

  173. 	float grooveAmount = 1.0f;

  174. 

  175. 	bool pingPong = false;

  176. 	bool reverse = false;

  177. 	int grainNumbers;

  178. 	bool tapMuted[NUM_TAPS+1];

  179. 	bool tapStacked[NUM_TAPS+1];

  180. 	int lastFilterType[NUM_TAPS+1];

  181. 	float lastTapFc[NUM_TAPS+1];

  182. 	float lastTapQ[NUM_TAPS+1];

  183. 	float tapPitchShift[NUM_TAPS+1];

  184. 	float tapDetune[NUM_TAPS+1];

  185. 	int tapFilterType[NUM_TAPS+1];

  186. 	int feedbackTap[CHANNELS] = {NUM_TAPS-1,NUM_TAPS-1};

  187. 	float feedbackSlip[CHANNELS] = {0.0f,0.0f};

  188. 	float feedbackPitch[CHANNELS] = {0.0f,0.0f};

  189. 	float feedbackDetune[CHANNELS] = {0.0f,0.0f};

  190. 	float delayTime[NUM_TAPS+1][CHANNELS];

  191. 	float actualDelayTime[NUM_TAPS+1][CHANNELS][2];

  192. 	float initialWindowedOutput[NUM_TAPS+1][CHANNELS][2];

  193. 

  194. 	StateVariableFilterState<T> filterStates[NUM_TAPS][CHANNELS];

  195.     StateVariableFilterParams<T> filterParams[NUM_TAPS];

  196. 	RCFilter lowpassFilter[CHANNELS];

  197. 	RCFilter highpassFilter[CHANNELS];

  198. 

  199. 	const char* filterNames[5] = {"O","L","H","B","N"};

  200. 	

  201. 	clouds::PitchShifter pitch_shifter_[NUM_TAPS+1][CHANNELS][MAX_GRAINS];

  202. 	SchmittTrigger clockTrigger,pingPongTrigger,reverseTrigger,clearBufferTrigger,mutingTrigger[NUM_TAPS],stackingTrigger[NUM_TAPS];

  203. 	float divisions[DIVISIONS] = {1/256.0f,1/192.0f,1/128.0f,1/96.0f,1/64.0f,1/48.0f,1/32.0f,1/24.0f,1/16.0f,1/13.0f,1/12.0f,1/11.0f,1/8.0f,1/7.0f,1/6.0f,1/5.0f,1/4.0f,1/3.0f,1/2.0f,1/1.5f,1};

  204. 	const char* divisionNames[DIVISIONS] = {"/256","/192","/128","/96","/64","/48","/32","/24","/16","/13","/12","/11","/8","/7","/6","/5","/4","/3","/2","/1.5","x 1"};

  205. 	int division;

  206. 	float time = 0.0;

  207. 	float duration = 0;

  208. 	float baseDelay;

  209. 	bool secondClockReceived = false;

  210. 

  211. 	LowFrequencyOscillator sinOsc[2];

  212. 	MultiTapDoubleRingBuffer<float, HISTORY_SIZE,NUM_TAPS+1> historyBuffer[CHANNELS][2];

  213. 	ReverseRingBuffer<float, HISTORY_SIZE> reverseHistoryBuffer[CHANNELS];

  214. 	float pitchShiftBuffer[NUM_TAPS+1][CHANNELS][MAX_GRAINS][MAX_GRAIN_SIZE];

  215. 	clouds::FloatFrame pitchShiftOut_;

  216. 	DoubleRingBuffer<float, 16> outBuffer[NUM_TAPS+1][CHANNELS][2]; 

  217. 	SampleRateConverter<1> src;

  218. 	float lastFeedback[CHANNELS] = {0.0f,0.0f};

  219. 

  220. 	float lerp(float v0, float v1, float t) {

  221. 	  return (1 - t) * v0 + t * v1;

  222. 	}

  223. 

  224. 	float SemitonesToRatio(float semiTone) {

  225. 		return powf(2,semiTone/12.0f);

  226. 	}

  227. 

  228. 	PortlandWeather() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {

  229. 		sinOsc[1].phase = 0.25; //90 degrees out

  230. 

  231. 		for (int i = 0; i <= NUM_TAPS; ++i) {

  232. 			tapMuted[i] = false;

  233. 			tapStacked[i] = false;

  234. 			tapPitchShift[i] = 0.0f;

  235. 			tapDetune[i] = 0.0f;

  236. 			filterParams[i].setMode(StateVariableFilterParams<T>::Mode::LowPass);

  237. 			filterParams[i].setQ(5); 	

  238. 	        filterParams[i].setFreq(T(800.0f / engineGetSampleRate()));

  239. 

  240. 	        for(int j=0;j < CHANNELS;j++) {

  241. 	        	actualDelayTime[i][j][0] = 0.0f;

  242. 	        	actualDelayTime[i][j][1] = 0.0f;

  243. 	        	for(int k=0;k<MAX_GRAINS;k++) {

  244. 	    	 	   pitch_shifter_[i][j][k].Init(pitchShiftBuffer[i][j][k],k*0.25f);

  245. 	    		}

  246. 	    	}

  247. 	    }

  248. 

  249. 	    //Initialize the feedback pitch shifters

  250.         for(int j=0;j < CHANNELS;j++) {

  251.         	for(int k=0;k<MAX_GRAINS;k++) {

  252.     	 	   pitch_shifter_[NUM_TAPS][j][k].Init(pitchShiftBuffer[NUM_TAPS][j][k],k*0.25f);

  253.     		}

  254.     	}

  255. 

  256. 	}

  257. 

  258. 	const char* tapNames[NUM_TAPS+2] {"1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","ALL","EXT"};

  259. 	const char* grainNames[MAX_GRAINS] {"1","2","4","Raw"};

  260. 

  261. 

  262. 	json_t *toJson() override {

  263. 		json_t *rootJ = json_object();

  264. 		json_object_set_new(rootJ, "pingPong", json_integer((int) pingPong));

  265. 

  266. 		//json_object_set_new(rootJ, "reverse", json_integer((int) reverse));

  267. 		

  268. 		for(int i=0;i<NUM_TAPS;i++) {

  269. 			//This is so stupid!!! why did he not use strings?

  270. 			char buf[100];

  271. 			strcpy(buf, "muted");

  272. 			strcat(buf, tapNames[i]);

  273. 			json_object_set_new(rootJ, buf, json_integer((int) tapMuted[i]));

  274. 

  275. 			strcpy(buf, "stacked");

  276. 			strcat(buf, tapNames[i]);

  277. 			json_object_set_new(rootJ, buf, json_integer((int) tapStacked[i]));

  278. 		}

  279. 		return rootJ;

  280. 	}

  281. 

  282. 	void fromJson(json_t *rootJ) override {

  283. 

  284. 		json_t *sumJ = json_object_get(rootJ, "pingPong");

  285. 		if (sumJ) {

  286. 			pingPong = json_integer_value(sumJ);			

  287. 		}

  288. 

  289. 		//json_t *sumR = json_object_get(rootJ, "reverse");

  290. 		//if (sumR) {

  291. 		//	reverse = json_integer_value(sumR);			

  292. 		//}

  293. 		

  294. 		char buf[100];			

  295. 		for(int i=0;i<NUM_TAPS;i++) {

  296. 			strcpy(buf, "muted");

  297. 			strcat(buf, tapNames[i]);

  298. 

  299. 			json_t *sumJ = json_object_get(rootJ, buf);

  300. 			if (sumJ) {

  301. 				tapMuted[i] = json_integer_value(sumJ);			

  302. 			}

  303. 		}

  304. 

  305. 		for(int i=0;i<NUM_TAPS;i++) {

  306. 			strcpy(buf, "stacked");

  307. 			strcat(buf, tapNames[i]);

  308. 

  309. 			json_t *sumJ = json_object_get(rootJ, buf);

  310. 			if (sumJ) {

  311. 				tapStacked[i] = json_integer_value(sumJ);

  312. 			}

  313. 		}

  314. 		

  315. 	}

  316. 

  317. 

  318. 	void step() override;

  319. };

  320. 

  321. 

  322. void PortlandWeather::step() {

  323. 	sinOsc[0].step(1.0 / engineGetSampleRate());

  324. 	sinOsc[1].step(1.0 / engineGetSampleRate());

  325. 

  326. 	if (clearBufferTrigger.process(params[CLEAR_BUFFER_PARAM].value)) {

  327. 		for(int i=0;i<CHANNELS;i++) {

  328. 			historyBuffer[i][0].clear();

  329. 			historyBuffer[i][1].clear();

  330. 		}

  331. 	}

  332. 

  333. 

  334. 	tapGroovePattern = (int)clamp(params[GROOVE_TYPE_PARAM].value + (inputs[GROOVE_TYPE_CV_INPUT].value / 10.0f),0.0f,15.0);

  335. 	grooveAmount = clamp(params[GROOVE_AMOUNT_PARAM].value + (inputs[GROOVE_AMOUNT_CV_INPUT].value / 10.0f),0.0f,1.0f);

  336. 

  337. 	float divisionf = params[CLOCK_DIV_PARAM].value;

  338. 	if(inputs[CLOCK_DIVISION_CV_INPUT].active) {

  339. 		divisionf +=(inputs[CLOCK_DIVISION_CV_INPUT].value * (DIVISIONS / 10.0));

  340. 	}

  341. 	divisionf = clamp(divisionf,0.0f,20.0f);

  342. 	division = (DIVISIONS-1) - int(divisionf); //TODO: Reverse Division Order

  343. 

  344. 	time += 1.0 / engineGetSampleRate();

  345. 	if(inputs[CLOCK_INPUT].active) {

  346. 		if(clockTrigger.process(inputs[CLOCK_INPUT].value)) {

  347. 			if(secondClockReceived) {

  348. 				duration = time;

  349. 			}

  350. 			time = 0;

  351. 			//secondClockReceived = true;			

  352. 			secondClockReceived = !secondClockReceived;			

  353. 		}

  354. 		//lights[CLOCK_LIGHT].value = time > (duration/2.0);

  355. 	}

  356. 	

  357. 	if(inputs[CLOCK_INPUT].active) {

  358. 		baseDelay = duration / divisions[division];

  359. 	} else {

  360. 		baseDelay = clamp(params[TIME_PARAM].value + inputs[TIME_CV_INPUT].value, 0.001f, 10.0f);

  361. 		//baseDelay = clamp(params[TIME_PARAM].value, 0.001f, 10.0f);			

  362. 	}

  363. 

  364. 	if (pingPongTrigger.process(params[PING_PONG_PARAM].value + inputs[PING_PONG_INPUT].value)) {

  365. 		pingPong = !pingPong;

  366. 	}

  367. 	lights[PING_PONG_LIGHT].value = pingPong;

  368. 

  369. 	if (reverseTrigger.process(params[REVERSE_PARAM].value + inputs[REVERSE_INPUT].value)) {

  370. 		reverse = !reverse;

  371. 		if(reverse) {

  372. 			for(int channel =0;channel <CHANNELS;channel++) {

  373. 				reverseHistoryBuffer[channel].clear();

  374. 			}

  375. 		}

  376. 	}

  377. 	lights[REVERSE_LIGHT].value = reverse;

  378. 

  379. 	grainNumbers = (int)params[GRAIN_QUANTITY_PARAM].value;

  380. 

  381. 	for(int channel = 0;channel < CHANNELS;channel++) {

  382. 		// Get input to delay block

  383. 		float in = 0.0f;

  384. 		if(channel == 0) {

  385. 			in = inputs[IN_L_INPUT].value;

  386. 		} else {

  387. 			in = inputs[IN_R_INPUT].active ? inputs[IN_R_INPUT].value : inputs[IN_L_INPUT].value;			

  388. 		}

  389. 		feedbackTap[channel] = (int)clamp(params[FEEDBACK_TAP_L_PARAM+channel].value + (inputs[FEEDBACK_TAP_L_INPUT+channel].value / 10.0f),0.0f,17.0);

  390. 		feedbackSlip[channel] = clamp(params[FEEDBACK_L_SLIP_PARAM+channel].value + (inputs[FEEDBACK_L_SLIP_CV_INPUT+channel].value / 10.0f),-0.5f,0.5);

  391. 		float feedbackAmount = clamp(params[FEEDBACK_PARAM].value + (inputs[FEEDBACK_INPUT].value / 10.0f), 0.0f, 1.0f);

  392. 		float feedbackInput = lastFeedback[channel];

  393. 

  394. 		float dry = in + feedbackInput * feedbackAmount;

  395. 

  396. 		float dryToUse = dry; //Normally the same as dry unless in reverse mode

  397. 

  398. 		// Push dry sample into reverse history buffer

  399. 		reverseHistoryBuffer[channel].push(dry);

  400. 		if(reverse) {

  401. 			float reverseDry = reverseHistoryBuffer[channel].shift();

  402. 			dryToUse = reverseDry;

  403. 		}

  404. 

  405. 		// Push dry sample into history buffer

  406. 		for(int dualIndex=0;dualIndex<2;dualIndex++) {

  407. 			if (!historyBuffer[channel][dualIndex].full(NUM_TAPS-1)) {

  408. 				historyBuffer[channel][dualIndex].push(dryToUse);

  409. 			}

  410. 		}

  411. 

  412. 		float wet = 0.0f; // This is the mix of delays and input that is outputed

  413. 		float feedbackValue = 0.0f; // This is the output of a tap that gets sent back to input

  414. 		float activeTapCount = 0.0f; // This will be used to normalize output

  415. 		for(int tap = 0; tap <= NUM_TAPS;tap++) { 

  416. 

  417. 			// Stacking

  418. 			if (tap < NUM_TAPS -1 && stackingTrigger[tap].process(params[TAP_STACKED_PARAM+tap].value + inputs[TAP_STACK_CV_INPUT+tap].value)) {

  419. 				tapStacked[tap] = !tapStacked[tap];

  420. 			}

  421. 

  422. 			//float pitch_grain_size = 1.0f; //Can be between 0 and 1

  423. 			float pitch_grain_size = params[GRAIN_SIZE_PARAM].value; //Can be between 0 and 1

  424. 			float pitch,detune;

  425. 			if (tap < NUM_TAPS) {

  426. 				pitch = floor(params[TAP_PITCH_SHIFT_PARAM+tap].value + (inputs[TAP_PITCH_SHIFT_CV_INPUT+tap].value*2.4f));

  427. 				detune = floor(params[TAP_DETUNE_PARAM+tap].value + (inputs[TAP_DETUNE_CV_INPUT+tap].value*10.0f));

  428. 				tapPitchShift[tap] = pitch;

  429. 				tapDetune[tap] = detune;

  430. 			} else {

  431. 				pitch = floor(params[FEEDBACK_L_PITCH_SHIFT_PARAM+channel].value + (inputs[FEEDBACK_L_PITCH_SHIFT_CV_INPUT+channel].value*2.4f));

  432. 				detune = floor(params[FEEDBACK_L_DETUNE_PARAM+channel].value + (inputs[FEEDBACK_L_DETUNE_CV_INPUT+channel].value*10.0f));		

  433. 				feedbackPitch[channel] = pitch;

  434. 				feedbackDetune[channel] = detune;		

  435. 			}

  436. 			pitch += detune/100.0f; 

  437. 

  438. 			float delayMod = 0.0f;

  439. 

  440. 			//Normally the delay tap is the same as the tap itself, unless it is stacked, then it is its neighbor;

  441. 			int delayTap = tap;

  442. 			while(delayTap < NUM_TAPS && tapStacked[delayTap]) {

  443. 				delayTap++;			

  444. 			}

  445. 			//Pull feedback off of normal tap time

  446. 			if(tap == NUM_TAPS && feedbackTap[channel] < NUM_TAPS) {

  447. 				delayTap = feedbackTap[channel];

  448. 				delayMod = feedbackSlip[channel] * baseDelay;

  449. 			}

  450. 

  451. 			// Compute delay time in seconds

  452. 			float delay = baseDelay * lerp(tapGroovePatterns[0][delayTap],tapGroovePatterns[tapGroovePattern][delayTap],grooveAmount); //Balance between straight time and groove

  453. 

  454. 			//External feedback time

  455. 			if(tap == NUM_TAPS && feedbackTap[channel] == NUM_TAPS+1) {

  456. 				delay = clamp(inputs[EXTERNAL_DELAY_TIME_INPUT].value, 0.001f, 10.0f);

  457. 			}

  458. 

  459. 

  460. 			if(inputs[TIME_CV_INPUT].active) { //The CV can change either clocked or set delay by 10MS

  461. 				delayMod += (0.001f * inputs[TIME_CV_INPUT].value); 

  462. 			}

  463. 

  464. 			delayTime[tap][channel] = delay + delayMod;

  465. 

  466. 

  467. 			//Set reverse size

  468. 			if(tap == NUM_TAPS) {

  469. 				reverseHistoryBuffer[channel].setDelaySize((delay+delayMod) * engineGetSampleRate());

  470. 			}

  471. 

  472. 

  473. 			for(int dualIndex=0;dualIndex<2;dualIndex++) {

  474. 				//if((actualDelayTime[tap][channel][dualIndex] != delayTime[tap][channel] && sinOsc[dualIndex].progress() >= 1) || actualDelayTime[tap][channel][dualIndex] == 0.0f) {

  475. 				if((actualDelayTime[tap][channel][dualIndex] != delayTime[tap][channel]) || actualDelayTime[tap][channel][dualIndex] == 0.0f) {

  476. 					actualDelayTime[tap][channel][dualIndex] = delayTime[tap][channel];

  477. 					sinOsc[dualIndex].reset();									

  478. 				}

  479. 

  480. 				float index = actualDelayTime[tap][channel][dualIndex] * engineGetSampleRate();

  481. 

  482. 				// How many samples do we need consume to catch up?

  483. 				float consume = index - historyBuffer[channel][dualIndex].size(tap);

  484. 

  485. 				if (outBuffer[tap][channel][dualIndex].empty()) {

  486. 					int inFrames = min(historyBuffer[channel][dualIndex].size(tap), 16); 

  487. 					

  488. 					double ratio = 1.0;

  489. 					if (consume <= -16) 

  490. 						ratio = 0.5;

  491. 					else if (consume >= 16) 

  492. 						ratio = 2.0;

  493. 

  494. 					float inSR = engineGetSampleRate();

  495. 			        float outSR = ratio * inSR;

  496. 

  497. 			        int outFrames = outBuffer[tap][channel][dualIndex].capacity();

  498. 			        src.setRates(inSR, outSR);

  499. 			        src.process((const Frame<1>*)historyBuffer[channel][dualIndex].startData(tap), &inFrames, (Frame<1>*)outBuffer[tap][channel][dualIndex].endData(), &outFrames);

  500. 			        outBuffer[tap][channel][dualIndex].endIncr(outFrames);

  501. 			        historyBuffer[channel][dualIndex].startIncr(tap, inFrames);

  502. 				}

  503. 

  504. 				if (!outBuffer[tap][channel][dualIndex].empty()) {

  505. 					initialWindowedOutput[tap][channel][dualIndex] = outBuffer[tap][channel][dualIndex].shift();

  506. 				}

  507. 			}	

  508. 

  509. 			float wetTap = 0.0f;	

  510. 			float initialOutput = (sinOsc[0].sin() * sinOsc[0].sin() * initialWindowedOutput[tap][channel][0]) + (sinOsc[1].sin() * sinOsc[1].sin() * initialWindowedOutput[tap][channel][1]);

  511. 

  512. 			float grainVolumeScaling = 1;

  513. 			for(int k=0;k<MAX_GRAINS;k++) {

  514.         		pitchShiftOut_.l = initialOutput;

  515. 				//Apply Pitch Shifting

  516. 			    pitch_shifter_[tap][channel][k].set_ratio(SemitonesToRatio(pitch));

  517. 			    pitch_shifter_[tap][channel][k].set_size(pitch_grain_size);

  518. 

  519. 			    //TODO: Put back into outBuffer

  520. 			    bool useTriangleWindow = grainNumbers != 4;

  521. 			    pitch_shifter_[tap][channel][k].Process(&pitchShiftOut_,useTriangleWindow); 

  522. 			    if(k == 0) {

  523. 			    	wetTap +=pitchShiftOut_.l; //First one always use

  524. 			    } else if (k == 2 && grainNumbers >= 2) {

  525. 			    	wetTap +=pitchShiftOut_.l; //Use middle grain for 2

  526. 			    	grainVolumeScaling = 1.414;

  527. 			    } else if (k != 2 && grainNumbers == 3) {

  528. 			    	wetTap +=pitchShiftOut_.l; //Use them all

  529. 			    	grainVolumeScaling = 2;

  530. 			    }

  531. 			}

  532.     		wetTap = wetTap / grainVolumeScaling;		        	

  533. 	        	 

  534. 

  535. 			//Feedback tap doesn't get panned or filtered

  536.         	if(tap < NUM_TAPS) {

  537. 

  538. 				// Muting

  539. 				if (mutingTrigger[tap].process(params[TAP_MUTE_PARAM+tap].value + inputs[TAP_MUTE_CV_INPUT+tap].value)) {

  540. 					tapMuted[tap] = !tapMuted[tap];

  541. 					if(!tapMuted[tap]) {

  542. 						activeTapCount +=1.0f;

  543. 					}

  544. 				}

  545. 

  546. 				float pan = 0.0f;

  547. 				if(channel == 0) {

  548. 					pan = clamp(1.0-(params[TAP_PAN_PARAM+tap].value + (inputs[TAP_PAN_CV_INPUT+tap].value / 10.0f)),0.0f,0.5f) * 2.0f;

  549. 				} else {

  550. 					pan = clamp(params[TAP_PAN_PARAM+tap].value + (inputs[TAP_PAN_CV_INPUT+tap].value / 10.0f),0.0f,0.5f) * 2.0f;

  551. 				}				

  552. 				wetTap = wetTap * clamp(params[TAP_MIX_PARAM+tap].value + (inputs[TAP_MIX_CV_INPUT+tap].value / 10.0f),0.0f,1.0f) * pan;

  553. 			

  554. 

  555. 				int tapFilterType = (int)params[TAP_FILTER_TYPE_PARAM+tap].value;

  556. 				// Apply Filter to tap wet output			

  557. 				if(tapFilterType != FILTER_NONE) {

  558. 					if(tapFilterType != lastFilterType[tap]) {

  559. 						switch(tapFilterType) {

  560. 							case FILTER_LOWPASS:

  561. 							filterParams[tap].setMode(StateVariableFilterParams<T>::Mode::LowPass);

  562. 							break;

  563. 							case FILTER_HIGHPASS:

  564. 							filterParams[tap].setMode(StateVariableFilterParams<T>::Mode::HiPass);

  565. 							break;

  566. 							case FILTER_BANDPASS:

  567. 							filterParams[tap].setMode(StateVariableFilterParams<T>::Mode::BandPass);

  568. 							break;

  569. 							case FILTER_NOTCH:

  570. 							filterParams[tap].setMode(StateVariableFilterParams<T>::Mode::Notch);

  571. 							break;

  572. 						}					

  573. 					}

  574. 

  575. 					float cutoffExp = clamp(params[TAP_FC_PARAM+tap].value + inputs[TAP_FC_CV_INPUT+tap].value / 10.0f,0.0f,1.0f); 

  576. 					float tapFc = minCutoff * powf(maxCutoff / minCutoff, cutoffExp) / engineGetSampleRate();

  577. 					if(lastTapFc[tap] != tapFc) {

  578. 						filterParams[tap].setFreq(T(tapFc));

  579. 						lastTapFc[tap] = tapFc;

  580. 					}

  581. 					float tapQ = clamp(params[TAP_Q_PARAM+tap].value + (inputs[TAP_Q_CV_INPUT+tap].value / 10.0f),0.01f,1.0f) * 50; 

  582. 					if(lastTapQ[tap] != tapQ) {

  583. 						filterParams[tap].setQ(tapQ); 

  584. 						lastTapQ[tap] = tapQ;

  585. 					}

  586. 					wetTap = StateVariableFilter<T>::run(wetTap, filterStates[tap][channel], filterParams[tap]);

  587. 				}

  588. 				lastFilterType[tap] = tapFilterType;

  589. 

  590. 				if(tapMuted[tap]) {

  591. 					wetTap = 0.0f;

  592. 				}

  593. 

  594. 				wet += wetTap;

  595. 

  596. 				lights[TAP_STACKED_LIGHT+tap].value = tapStacked[tap];

  597. 				lights[TAP_MUTED_LIGHT+tap].value = (tapMuted[tap]);	

  598. 

  599. 			} else {

  600. 				feedbackValue = wetTap;

  601. 			}

  602. 		}

  603. 		

  604. 		//activeTapCount = 16.0f;

  605. 		//wet = wet / activeTapCount * sqrt(activeTapCount);	

  606. 

  607. 		if(feedbackTap[channel] == NUM_TAPS) { //This would be the All  Taps setting

  608. 			//float feedbackScaling = 4.0f; // Trying to make full feedback not, well feedback

  609. 			//feedbackValue = wet * feedbackScaling / NUM_TAPS; 

  610. 			feedbackValue = wet; 

  611. 		}

  612. 

  613. 			

  614. 		//Apply global filtering

  615. 		// TODO Make it sound better

  616. 		float color = clamp(params[FEEDBACK_TONE_PARAM].value + inputs[FEEDBACK_TONE_INPUT].value / 10.0f, 0.0f, 1.0f);

  617. 		float lowpassFreq = 10000.0f * powf(10.0f, clamp(2.0f*color, 0.0f, 1.0f));

  618. 		lowpassFilter[channel].setCutoff(lowpassFreq / engineGetSampleRate());

  619. 		lowpassFilter[channel].process(feedbackValue);

  620. 		feedbackValue = lowpassFilter[channel].lowpass();

  621. 		float highpassFreq = 10.0f * powf(100.0f, clamp(2.0f*color - 1.0f, 0.0f, 1.0f));

  622. 		highpassFilter[channel].setCutoff(highpassFreq / engineGetSampleRate());

  623. 		highpassFilter[channel].process(feedbackValue);

  624. 		feedbackValue = highpassFilter[channel].highpass();

  625. 

  626. 

  627. 		outputs[FEEDBACK_L_OUTPUT+channel].value = feedbackValue;

  628. 

  629. 		if(inputs[FEEDBACK_L_RETURN+channel].active) {

  630. 			feedbackValue = inputs[FEEDBACK_L_RETURN+channel].value;

  631. 		}

  632. 

  633. 		//feedbackValue = clamp(feedbackValue,-5.0f,5.0f); // Let's keep things civil

  634. 

  635. 

  636. 		int feedbackDestinationChannel = channel;

  637. 		if (pingPong) {

  638. 			feedbackDestinationChannel = 1 - channel;

  639. 		}

  640. 		lastFeedback[feedbackDestinationChannel] = feedbackValue;

  641. 

  642. 		float mix = clamp(params[MIX_PARAM].value + inputs[MIX_INPUT].value / 10.0f, 0.0f, 1.0f);

  643. 		float out = crossfade(in, wet, mix);  // Not sure this should be wet

  644. 		

  645. 		outputs[OUT_L_OUTPUT + channel].value = out;

  646. 	}

  647. }

  648. 

  649. struct PWStatusDisplay : TransparentWidget {

  650. 	PortlandWeather *module;

  651. 	int frame = 0;

  652. 	std::shared_ptr<Font> fontNumbers,fontText;

  653. 

  654. 	

  655. 

  656. 	PWStatusDisplay() {

  657. 		fontNumbers = Font::load(assetPlugin(plugin, "res/fonts/01 Digit.ttf"));

  658. 		fontText = Font::load(assetPlugin(plugin, "res/fonts/DejaVuSansMono.ttf"));

  659. 	}

  660. 

  661. 	void drawProgress(NVGcontext *vg, float phase) 

  662. 	{

  663. 		const float rotate90 = (M_PI) / 2.0;

  664. 		float startArc = 0 - rotate90;

  665. 		float endArc = (phase * M_PI * 2) - rotate90;

  666. 

  667. 		// Draw indicator

  668. 		nvgFillColor(vg, nvgRGBA(0xff, 0xff, 0x20, 0xff));

  669. 		{

  670. 			nvgBeginPath(vg);

  671. 			nvgArc(vg,75.8,170,35,startArc,endArc,NVG_CW);

  672. 			nvgLineTo(vg,75.8,170);

  673. 			nvgClosePath(vg);

  674. 		}

  675. 		nvgFill(vg);

  676. 	}

  677. 

  678. 	void drawDivision(NVGcontext *vg, Vec pos, int division) {

  679. 		nvgFontSize(vg, 28);

  680. 		nvgFontFaceId(vg, fontNumbers->handle);

  681. 		nvgTextLetterSpacing(vg, -2);

  682. 

  683. 		nvgFillColor(vg, nvgRGBA(0x00, 0xff, 0x00, 0xff));

  684. 		char text[128];

  685. 		snprintf(text, sizeof(text), "%s", module->divisionNames[division]);

  686. 		nvgText(vg, pos.x, pos.y, text, NULL);

  687. 	}

  688. 

  689. 	void drawDelayTime(NVGcontext *vg, Vec pos, float delayTime) {

  690. 		nvgFontSize(vg, 28);

  691. 		nvgFontFaceId(vg, fontNumbers->handle);

  692. 		nvgTextLetterSpacing(vg, -2);

  693. 

  694. 		nvgFillColor(vg, nvgRGBA(0x00, 0xff, 0x00, 0xff));

  695. 		char text[128];

  696. 		snprintf(text, sizeof(text), "%6.0f", delayTime*1000);	

  697. 		nvgText(vg, pos.x, pos.y, text, NULL);

  698. 	}

  699. 

  700. 	void drawGrooveType(NVGcontext *vg, Vec pos, int grooveType) {

  701. 		nvgFontSize(vg, 14);

  702. 		nvgFontFaceId(vg, fontText->handle);

  703. 		nvgTextLetterSpacing(vg, -2);

  704. 

  705. 		nvgFillColor(vg, nvgRGBA(0x00, 0xff, 0x00, 0xff));

  706. 		char text[128];

  707. 		snprintf(text, sizeof(text), "%s", module->grooveNames[grooveType]);

  708. 		nvgText(vg, pos.x, pos.y, text, NULL);

  709. 	}

  710. 

  711. 	void drawFeedbackTaps(NVGcontext *vg, Vec pos, int *feedbackTaps) {

  712. 		nvgFontSize(vg, 12);

  713. 		nvgFontFaceId(vg, fontNumbers->handle);

  714. 		nvgTextLetterSpacing(vg, -2);

  715. 

  716. 		nvgFillColor(vg, nvgRGBA(0x00, 0x00, 0x00, 0xff));

  717. 		for(int i=0;i<CHANNELS;i++) {

  718. 			char text[128];

  719. 			snprintf(text, sizeof(text), "%s", module->tapNames[feedbackTaps[i]]);

  720. 			nvgText(vg, pos.x + i*142, pos.y, text, NULL);

  721. 		}

  722. 	}

  723. 

  724. 	void drawFeedbackPitch(NVGcontext *vg, Vec pos, float *feedbackPitch) {

  725. 		nvgFontSize(vg, 12);

  726. 		nvgFontFaceId(vg, fontNumbers->handle);

  727. 		nvgTextLetterSpacing(vg, -2);

  728. 

  729. 		nvgFillColor(vg, nvgRGBA(0x00, 0x00, 0x00, 0xff));

  730. 		for(int i=0;i<CHANNELS;i++) {

  731. 			char text[128];

  732. 			snprintf(text, sizeof(text), "%-2.0f", feedbackPitch[i]);

  733. 			nvgText(vg, pos.x + i*142, pos.y, text, NULL);

  734. 		}

  735. 	}

  736. 

  737. 	void drawFeedbackDetune(NVGcontext *vg, Vec pos, float *feedbackDetune) {

  738. 		nvgFontSize(vg, 12);

  739. 		nvgFontFaceId(vg, fontNumbers->handle);

  740. 		nvgTextLetterSpacing(vg, -2);

  741. 

  742. 		nvgFillColor(vg, nvgRGBA(0x00, 0x00, 0x00, 0xff));

  743. 		for(int i=0;i<CHANNELS;i++) {

  744. 			char text[128];

  745. 			snprintf(text, sizeof(text), "%-3.0f", feedbackDetune[i]);

  746. 			nvgText(vg, pos.x + i*142, pos.y, text, NULL);

  747. 		}

  748. 	}

  749. 

  750. 

  751. 	void drawFilterTypes(NVGcontext *vg, Vec pos, int *filterType) {

  752. 		nvgFontSize(vg, 14);

  753. 		nvgFontFaceId(vg, fontText->handle);

  754. 		nvgTextLetterSpacing(vg, -2);

  755. 

  756. 		nvgFillColor(vg, nvgRGBA(0x00, 0x00, 0x00, 0xff));

  757. 		for(int i=0;i<NUM_TAPS;i++) {

  758. 			char text[128];

  759. 			snprintf(text, sizeof(text), "%s", module->filterNames[filterType[i]]);

  760. 			nvgText(vg, pos.x + i*50, pos.y, text, NULL);

  761. 		}

  762. 	}

  763. 

  764. 	void drawTapPitchShift(NVGcontext *vg, Vec pos, float *pitchShift) {

  765. 		nvgFontSize(vg, 14);

  766. 		nvgFontFaceId(vg, fontText->handle);

  767. 		nvgTextLetterSpacing(vg, -2);

  768. 

  769. 		nvgFillColor(vg, nvgRGBA(0x00, 0x00, 0x00, 0xff));

  770. 		for(int i=0;i<NUM_TAPS;i++) {

  771. 			char text[128];

  772. 			snprintf(text, sizeof(text), "%-2.0f", pitchShift[i]);

  773. 			nvgText(vg, pos.x + i*50, pos.y, text, NULL);

  774. 		}

  775. 	}

  776. 

  777. 	void drawTapDetune(NVGcontext *vg, Vec pos, float *detune) {

  778. 		nvgFontSize(vg, 14);

  779. 		nvgFontFaceId(vg, fontText->handle);

  780. 		nvgTextLetterSpacing(vg, -2);

  781. 

  782. 		nvgFillColor(vg, nvgRGBA(0x00, 0x00, 0x00, 0xff));

  783. 		for(int i=0;i<NUM_TAPS;i++) {

  784. 			char text[128];

  785. 			snprintf(text, sizeof(text), "%-3.0f", detune[i]);

  786. 			nvgText(vg, pos.x + i*50, pos.y, text, NULL);

  787. 		}

  788. 	}

  789. 

  790. 	void drawGrainNumbers(NVGcontext *vg, Vec pos, int grainNumbers) {

  791. 		nvgFontSize(vg, 12);

  792. 		nvgFontFaceId(vg, fontNumbers->handle);

  793. 		nvgTextLetterSpacing(vg, -2);

  794. 

  795. 		nvgFillColor(vg, nvgRGBA(0x00, 0x00, 0x00, 0xff));

  796. 		char text[128];

  797. 		snprintf(text, sizeof(text), "%s", module->grainNames[grainNumbers-1]);

  798. 		nvgText(vg, pos.x, pos.y, text, NULL);

  799. 	}

  800. 

  801. 	void draw(NVGcontext *vg) override {

  802. 		

  803. 		//drawProgress(vg,module->oscillator.progress());

  804. 		drawDivision(vg, Vec(150,65), module->division);

  805. 		drawDelayTime(vg, Vec(350,65), module->baseDelay);

  806. 		drawGrooveType(vg, Vec(147,125), module->tapGroovePattern);

  807. 		drawFeedbackTaps(vg, Vec(570,50), module->feedbackTap);

  808. 		drawFeedbackPitch(vg, Vec(570,150), module->feedbackPitch);

  809. 		drawFeedbackDetune(vg, Vec(570,200), module->feedbackDetune);

  810. 		drawFilterTypes(vg, Vec(80,420), module->lastFilterType);

  811. 		drawTapPitchShift(vg, Vec(78,585), module->tapPitchShift);

  812. 		drawTapDetune(vg, Vec(78,645), module->tapDetune);

  813. 		drawGrainNumbers(vg, Vec(800,60), module->grainNumbers);

  814. 	}

  815. };

  816. 

  817. 

  818. struct PortlandWeatherWidget : ModuleWidget {

  819. 	PortlandWeatherWidget(PortlandWeather *module);

  820. };

  821. 

  822. PortlandWeatherWidget::PortlandWeatherWidget(PortlandWeather *module) : ModuleWidget(module) {

  823. 	box.size = Vec(RACK_GRID_WIDTH*57, RACK_GRID_HEIGHT * 2);

  824. 

  825. 	{

  826. 		SVGPanel *panel = new SVGPanel();

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

  828. 		panel->setBackground(SVG::load(assetPlugin(plugin, "res/PortlandWeather.svg")));

  829. 		addChild(panel);

  830. 	}

  831. 

  832. 

  833. 	addChild(Widget::create<ScrewSilver>(Vec(15, 0)));

  834. 	addChild(Widget::create<ScrewSilver>(Vec(box.size.x-30, 0)));

  835. 	addChild(Widget::create<ScrewSilver>(Vec(15, 745)));

  836. 	addChild(Widget::create<ScrewSilver>(Vec(box.size.x-30, 745)));

  837. 

  838. 	{

  839. 		PWStatusDisplay *display = new PWStatusDisplay();

  840. 		display->module = module;

  841. 		display->box.pos = Vec(0, 0);

  842. 		display->box.size = Vec(box.size.x, 500);

  843. 		addChild(display);

  844. 	}

  845. 

  846. 	addParam(ParamWidget::create<RoundLargeBlackKnob>(Vec(57, 40), module, PortlandWeather::CLOCK_DIV_PARAM, 0, DIVISIONS-1, 0));

  847. 	addParam(ParamWidget::create<RoundLargeBlackKnob>(Vec(257, 40), module, PortlandWeather::TIME_PARAM, 0.0f, 10.0f, 0.350f));

  848. 	//addParam(ParamWidget::create<RoundLargeBlackKnob>(Vec(257, 40), module, PortlandWeather::GRID_PARAM, 0.001f, 10.0f, 0.350f));

  849. 

  850. 	addParam(ParamWidget::create<RoundLargeBlackKnob>(Vec(57, 110), module, PortlandWeather::GROOVE_TYPE_PARAM, 0.0f, 15.0f, 0.0f));

  851. 	addParam(ParamWidget::create<RoundLargeBlackKnob>(Vec(257, 110), module, PortlandWeather::GROOVE_AMOUNT_PARAM, 0.0f, 1.0f, 1.0f));

  852. 

  853. 	addParam(ParamWidget::create<RoundLargeBlackKnob>(Vec(57, 180), module, PortlandWeather::FEEDBACK_PARAM, 0.0f, 1.0f, 0.0f));

  854. 	addParam(ParamWidget::create<RoundBlackKnob>(Vec(157, 180), module, PortlandWeather::FEEDBACK_TONE_PARAM, 0.0f, 1.0f, 0.5f));

  855. 

  856. 	addParam(ParamWidget::create<RoundBlackKnob>(Vec(500, 30), module, PortlandWeather::FEEDBACK_TAP_L_PARAM, 0.0f, 17.0f, 15.0f));

  857. 	addParam(ParamWidget::create<RoundBlackKnob>(Vec(642, 30), module, PortlandWeather::FEEDBACK_TAP_R_PARAM, 0.0f, 17.0f, 15.0f));

  858. 	addParam(ParamWidget::create<RoundBlackKnob>(Vec(500, 80), module, PortlandWeather::FEEDBACK_L_SLIP_PARAM, -0.5f, 0.5f, 0.0f));

  859. 	addParam(ParamWidget::create<RoundBlackKnob>(Vec(642, 80), module, PortlandWeather::FEEDBACK_R_SLIP_PARAM, -0.5f, 0.5f, 0.0f));

  860. 	addParam(ParamWidget::create<RoundBlackKnob>(Vec(500, 130), module, PortlandWeather::FEEDBACK_L_PITCH_SHIFT_PARAM, -24.0f, 24.0f, 0.0f));

  861. 	addParam(ParamWidget::create<RoundBlackKnob>(Vec(642, 130), module, PortlandWeather::FEEDBACK_R_PITCH_SHIFT_PARAM, -24.0f, 24.0f, 0.0f));

  862. 	addParam(ParamWidget::create<RoundBlackKnob>(Vec(500, 180), module, PortlandWeather::FEEDBACK_L_DETUNE_PARAM, -99.0f, 99.0f, 0.0f));

  863. 	addParam(ParamWidget::create<RoundBlackKnob>(Vec(642, 180), module, PortlandWeather::FEEDBACK_R_DETUNE_PARAM, -99.0f, 99.0f, 0.0f));

  864. 

  865. 	addParam(ParamWidget::create<RoundBlackKnob>(Vec(766, 40), module, PortlandWeather::GRAIN_QUANTITY_PARAM, 1, 4, 1));

  866. 	//addParam(ParamWidget::create<RoundBlackKnob>(Vec(766, 110), module, PortlandWeather::GRAIN_SIZE_PARAM, 8, 11, 11));

  867. 	addParam(ParamWidget::create<RoundBlackKnob>(Vec(766, 110), module, PortlandWeather::GRAIN_SIZE_PARAM, 0.0f, 1.0f, 1.0f));

  868. 	

  869. 

  870. 	addParam(ParamWidget::create<CKD6>(Vec(766, 180), module, PortlandWeather::CLEAR_BUFFER_PARAM, 0.0f, 1.0f, 0.0f));

  871. 

  872. 

  873. 	addParam( ParamWidget::create<LEDButton>(Vec(372,182), module, PortlandWeather::REVERSE_PARAM, 0.0f, 1.0f, 0.0f));

  874. 	addChild(ModuleLightWidget::create<MediumLight<BlueLight>>(Vec(376, 186), module, PortlandWeather::REVERSE_LIGHT));

  875. 	addInput(Port::create<PJ301MPort>(Vec(392, 178), Port::INPUT, module, PortlandWeather::REVERSE_INPUT));

  876. 

  877. 	addParam( ParamWidget::create<LEDButton>(Vec(435,182), module, PortlandWeather::PING_PONG_PARAM, 0.0f, 1.0f, 0.0f));

  878. 	addChild(ModuleLightWidget::create<MediumLight<BlueLight>>(Vec(439, 186), module, PortlandWeather::PING_PONG_LIGHT));

  879. 	addInput(Port::create<PJ301MPort>(Vec(455, 178), Port::INPUT, module, PortlandWeather::PING_PONG_INPUT));

  880. 

  881. 

  882. 

  883. 	//last tap isn't stacked

  884. 	for (int i = 0; i< NUM_TAPS-1; i++) {

  885. 		addParam( ParamWidget::create<LEDButton>(Vec(54 + 50*i,239), module, PortlandWeather::TAP_STACKED_PARAM + i, 0.0f, 1.0f, 0.0f));

  886. 		addChild(ModuleLightWidget::create<MediumLight<BlueLight>>(Vec(58 + 50*i, 243), module, PortlandWeather::TAP_STACKED_LIGHT+i));

  887. 		addInput(Port::create<PJ301MPort>(Vec(74+ 50*i, 233), Port::INPUT, module, PortlandWeather::TAP_STACK_CV_INPUT+i));

  888. 	}

  889. 

  890. 	for (int i = 0; i < NUM_TAPS; i++) {

  891. 		addParam( ParamWidget::create<LEDButton>(Vec(54 + 50*i,260), module, PortlandWeather::TAP_MUTE_PARAM + i, 0.0f, 1.0f, 0.0f));

  892. 		addChild(ModuleLightWidget::create<MediumLight<RedLight>>(Vec(58 + 50*i, 264), module, PortlandWeather::TAP_MUTED_LIGHT+i));

  893. 		addInput(Port::create<PJ301MPort>(Vec(74+ 50*i, 260), Port::INPUT, module, PortlandWeather::TAP_MUTE_CV_INPUT+i));

  894. 

  895. 		addParam( ParamWidget::create<RoundBlackKnob>(Vec(48 + 50*i, 280), module, PortlandWeather::TAP_MIX_PARAM + i, 0.0f, 1.0f, 0.5f));

  896. 		addInput(Port::create<PJ301MPort>(Vec(51+ 50*i, 311), Port::INPUT, module, PortlandWeather::TAP_MIX_CV_INPUT+i));

  897. 		addParam( ParamWidget::create<RoundBlackKnob>(Vec(48 + 50*i, 340), module, PortlandWeather::TAP_PAN_PARAM + i, 0.0f, 1.0f, 0.5f));

  898. 		addInput(Port::create<PJ301MPort>(Vec(51 + 50*i, 371), Port::INPUT, module, PortlandWeather::TAP_PAN_CV_INPUT+i));

  899. 		addParam( ParamWidget::create<RoundBlackKnob>(Vec(48 + 50*i, 400), module, PortlandWeather::TAP_FILTER_TYPE_PARAM + i, 0, 4, 0));

  900. 		addParam( ParamWidget::create<RoundBlackKnob>(Vec(48 + 50*i, 440), module, PortlandWeather::TAP_FC_PARAM + i, 0.0f, 1.0f, 0.5f));

  901. 		addInput(Port::create<PJ301MPort>(Vec(51 + 50*i, 471), Port::INPUT, module, PortlandWeather::TAP_FC_CV_INPUT+i));

  902. 		addParam( ParamWidget::create<RoundBlackKnob>(Vec(48 + 50*i, 500), module, PortlandWeather::TAP_Q_PARAM + i, 0.01f, 1.0f, 0.5f));

  903. 		addInput(Port::create<PJ301MPort>(Vec(51 + 50*i, 531), Port::INPUT, module, PortlandWeather::TAP_Q_CV_INPUT+i));

  904. 		addParam( ParamWidget::create<RoundBlackKnob>(Vec(48 + 50*i, 560), module, PortlandWeather::TAP_PITCH_SHIFT_PARAM + i, -24.0f, 24.0f, 0.0f));

  905. 		addInput(Port::create<PJ301MPort>(Vec(51 + 50*i, 591), Port::INPUT, module, PortlandWeather::TAP_PITCH_SHIFT_CV_INPUT+i));

  906. 		addParam( ParamWidget::create<RoundBlackKnob>(Vec(48 + 50*i, 620), module, PortlandWeather::TAP_DETUNE_PARAM + i, -99.0f, 99.0f, 0.0f));

  907. 		addInput(Port::create<PJ301MPort>(Vec(51 + 50*i, 651), Port::INPUT, module, PortlandWeather::TAP_DETUNE_CV_INPUT+i));

  908. 	}

  909. 

  910. 	addInput(Port::create<PJ301MPort>(Vec(18, 50), Port::INPUT, module, PortlandWeather::CLOCK_INPUT));

  911. 

  912. 	addInput(Port::create<PJ301MPort>(Vec(100, 45), Port::INPUT, module, PortlandWeather::CLOCK_DIVISION_CV_INPUT));

  913. 	addInput(Port::create<PJ301MPort>(Vec(300, 45), Port::INPUT, module, PortlandWeather::TIME_CV_INPUT));

  914. 	//addInput(Port::create<PJ301MPort>(Vec(300, 45), Port::INPUT, module, PortlandWeather::GRID_CV_INPUT));

  915. 

  916. 	addInput(Port::create<PJ301MPort>(Vec(100, 115), Port::INPUT, module, PortlandWeather::GROOVE_TYPE_CV_INPUT));

  917. 	addInput(Port::create<PJ301MPort>(Vec(300, 115), Port::INPUT, module, PortlandWeather::GROOVE_AMOUNT_CV_INPUT));

  918. 

  919. 

  920. 	addInput(Port::create<PJ301MPort>(Vec(100, 185), Port::INPUT, module, PortlandWeather::FEEDBACK_INPUT));

  921. 	addInput(Port::create<PJ301MPort>(Vec(195, 182), Port::INPUT, module, PortlandWeather::FEEDBACK_TONE_INPUT));

  922. 	addInput(Port::create<PJ301MPort>(Vec(270, 182), Port::INPUT, module, PortlandWeather::EXTERNAL_DELAY_TIME_INPUT));

  923. 	addInput(Port::create<PJ301MPort>(Vec(538, 32), Port::INPUT, module, PortlandWeather::FEEDBACK_TAP_L_INPUT));

  924. 	addInput(Port::create<PJ301MPort>(Vec(680, 32), Port::INPUT, module, PortlandWeather::FEEDBACK_TAP_R_INPUT));

  925. 	addInput(Port::create<PJ301MPort>(Vec(538, 82), Port::INPUT, module, PortlandWeather::FEEDBACK_L_SLIP_CV_INPUT));

  926. 	addInput(Port::create<PJ301MPort>(Vec(680, 82), Port::INPUT, module, PortlandWeather::FEEDBACK_R_SLIP_CV_INPUT));

  927. 	addInput(Port::create<PJ301MPort>(Vec(538, 132), Port::INPUT, module, PortlandWeather::FEEDBACK_L_PITCH_SHIFT_CV_INPUT));

  928. 	addInput(Port::create<PJ301MPort>(Vec(680, 132), Port::INPUT, module, PortlandWeather::FEEDBACK_R_PITCH_SHIFT_CV_INPUT));

  929. 	addInput(Port::create<PJ301MPort>(Vec(538, 182), Port::INPUT, module, PortlandWeather::FEEDBACK_L_DETUNE_CV_INPUT));

  930. 	addInput(Port::create<PJ301MPort>(Vec(680, 182), Port::INPUT, module, PortlandWeather::FEEDBACK_R_DETUNE_CV_INPUT));

  931. 

  932. 

  933. 

  934. 	addParam(ParamWidget::create<RoundLargeBlackKnob>(Vec(440, 705), module, PortlandWeather::MIX_PARAM, 0.0f, 1.0f, 0.5f));

  935. 	addInput(Port::create<PJ301MPort>(Vec(480, 710), Port::INPUT, module, PortlandWeather::MIX_INPUT));

  936. 

  937. 

  938. 	addInput(Port::create<PJ301MPort>(Vec(75, 710), Port::INPUT, module, PortlandWeather::IN_L_INPUT));

  939. 	addInput(Port::create<PJ301MPort>(Vec(105, 710), Port::INPUT, module, PortlandWeather::IN_R_INPUT));

  940. 	addOutput(Port::create<PJ301MPort>(Vec(200, 710), Port::OUTPUT, module, PortlandWeather::FEEDBACK_L_OUTPUT));

  941. 	addOutput(Port::create<PJ301MPort>(Vec(230, 710), Port::OUTPUT, module, PortlandWeather::FEEDBACK_R_OUTPUT));

  942. 	addInput(Port::create<PJ301MPort>(Vec(306, 710), Port::INPUT, module, PortlandWeather::FEEDBACK_L_RETURN));

  943. 	addInput(Port::create<PJ301MPort>(Vec(336, 710), Port::INPUT, module, PortlandWeather::FEEDBACK_R_RETURN));

  944. 	addOutput(Port::create<PJ301MPort>(Vec(595, 710), Port::OUTPUT, module, PortlandWeather::OUT_L_OUTPUT));

  945. 	addOutput(Port::create<PJ301MPort>(Vec(625, 710), Port::OUTPUT, module, PortlandWeather::OUT_R_OUTPUT));

  946. }

  947. 

  948. } // namespace rack_plugin_FrozenWasteland

  949. 

  950. using namespace rack_plugin_FrozenWasteland;

  951. 

  952. RACK_PLUGIN_MODEL_INIT(FrozenWasteland, PortlandWeather) {

  953.    Model *modelPortlandWeather = Model::create<PortlandWeather, PortlandWeatherWidget>("Frozen Wasteland", "PortlandWeather", "Portland Weather", DELAY_TAG);

  954.    return modelPortlandWeather;

  955. }