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.
1327 Commits
4 Branches
540MB
Tree: 3d2532bde8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3d2532bde8'
${ noResults }
Rack/plugins/community/repos/moDllz/src/XBender.cpp

686 lines
21KB
Raw Blame History 

  1. #include "dsp/digital.hpp"

  2. #include "moDllz.hpp"

  3. #include "dsp/filter.hpp"

  4. /*

  5.  * XBender

  6.  */

  7. 

  8. namespace rack_plugin_moDllz {

  9. 

  10. struct XBender : Module {

  11. 	enum ParamIds {

  12. 		XBEND_PARAM,

  13. 		XBENDCVTRIM_PARAM,

  14. 		XBENDRANGE_PARAM,

  15. 		BEND_PARAM,

  16. 		BENDCVTRIM_PARAM,

  17. 		AXISXFADE_PARAM,

  18. 		AXISSLEW_PARAM,

  19. 		AXISTRNSUP_PARAM,

  20. 		AXISTRNSDWN_PARAM,

  21. 		AXISSHIFTTRIM_PARAM,

  22. 		AXISSELECT_PARAM = 10,

  23. 		AXISSELECTCV_PARAM = 18,

  24. 		SNAPAXIS_PARAM,

  25. 		YCENTER_PARAM,

  26. 		YZOOM_PARAM,

  27. 		AUTOZOOM_PARAM,

  28. 		NUM_PARAMS

  29. 	};

  30. 	enum InputIds {

  31. 		IN_INPUT,

  32. 		XBENDCV_INPUT = 8,

  33. 		XBENDRANGE_INPUT,

  34. 		BENDCV_INPUT,

  35. 		AXISSELECT_INPUT,

  36. 		AXISEXT_INPUT,

  37. 		AXISXFADE_INPUT,

  38. 		AXISSHIFT_INPUT,

  39. 		AXISSLEW_INPUT,

  40. 		NUM_INPUTS

  41. 	};

  42. 	enum OutputIds {

  43. 		OUT_OUTPUT,

  44. 		AXIS_OUTPUT = 8,

  45. 		NUM_OUTPUTS

  46. 	};

  47. 	enum LightIds {

  48. 		AXIS_LIGHT,

  49. 		AUTOZOOM_LIGHT = 8,

  50. 		SNAPAXIS_LIGHT,

  51. 		NUM_LIGHTS

  52. 	};

  53. 	

  54. 	float inAxis = 0.f;

  55. 	float axisSlew = 0.f;

  56. 	int axisTransParam = 0;

  57. 	float finalAxis = 0.f;

  58. 	float AxisShift =  0.f;

  59. 	float axisXfade;

  60. 	float selectedAxisF = 0.f;

  61. 	int selectedAxisI = 0;

  62. 	

  63. 	float dZoom = 1.f;

  64. 	float dCenter = 0.5f;

  65. 	int frameAutoZoom = 0;

  66. 	

  67. 	float slewchanged = 0.f;

  68. 	float XBenderKnobVal = 0.f;

  69. 	float XBenderKnobCV = 0.f;

  70. 	float xbend = 0.f;

  71. 	

  72. 	float testVal = 0.f;

  73. 	

  74. 	bool newZoom = false;

  75. 	

  76. 	SchmittTrigger axisTransUpTrigger;

  77. 	SchmittTrigger axisTransDwnTrigger;

  78. 	SchmittTrigger axisSelectTrigger[8];

  79. 	

  80. 	struct ioXBended {

  81. 		float inx = 0.0f;

  82. 		float xout = 0.0f;

  83. 		bool iactive = false;

  84. 	};

  85. 	

  86. 	ioXBended ioxbended[8];

  87. 	

  88. 	SlewLimiter slewlimiter;

  89. 	

  90. 	

  91. 	XBender() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {}

  92. 	

  93. 	void step() override;

  94. 	void onReset() override {

  95. 		for (int ix = 0; ix < 8 ; ix++){

  96. 		outputs[OUT_OUTPUT + ix].value = inputs[IN_INPUT + ix].value;

  97. 		}

  98. 	}

  99. 	json_t *toJson() override {

  100. 		json_t *rootJ = json_object();

  101. 		json_object_set_new(rootJ, "selectedAxisI", json_integer(selectedAxisI));

  102. 		json_object_set_new(rootJ, "axisTransParam", json_integer(axisTransParam));

  103. 		return rootJ;

  104. 	}

  105. 	

  106. 	void fromJson(json_t *rootJ) override {

  107. 		json_t *selectedAxisIJ = json_object_get(rootJ,("selectedAxisI"));

  108. 		selectedAxisI = json_integer_value(selectedAxisIJ);

  109. 		json_t *axisTransParamJ = json_object_get(rootJ,("axisTransParam"));

  110. 		axisTransParam = json_integer_value(axisTransParamJ);

  111. 	}

  112. };

  113. 

  114. ///////////////////////////////////////////

  115. ///////////////STEP //////////////////

  116. /////////////////////////////////////////////

  117. 

  118. void XBender::step() {

  119. 

  120. 	

  121. 	if(inputs[AXISSELECT_INPUT].active) {

  122. 		if (params[SNAPAXIS_PARAM].value > 0.5f){

  123. 			selectedAxisI = (clamp(static_cast<int>(inputs[AXISSELECT_INPUT].value * 0.7), 0, 7));

  124. 			selectedAxisF = static_cast<float>(selectedAxisI);

  125. 			inAxis = inputs[selectedAxisI].value;

  126. 		} else {

  127. 			selectedAxisF = clamp(inputs[AXISSELECT_INPUT].value * 0.7, 0.f, 7.f);

  128. 			selectedAxisI = static_cast<int>(selectedAxisF);

  129. 			float ax_float = selectedAxisF - static_cast<float>(selectedAxisI);

  130. 			inAxis = (inputs[selectedAxisI].value * (1.f - ax_float) + (inputs[selectedAxisI + 1].value * ax_float));

  131. 		}

  132. 	}else{

  133. 		 inAxis = inputs[selectedAxisI].value;

  134. 	}

  135. 	

  136. 	lights[SNAPAXIS_LIGHT].value = (params[SNAPAXIS_PARAM].value > 0.5f)? 1.f : 0.f;

  137. 	

  138. 	axisXfade = clamp((params[AXISXFADE_PARAM].value + inputs[AXISXFADE_INPUT].value/ 10.f), 0.f, 1.f);

  139. 	

  140. 	if (inputs[AXISEXT_INPUT].active){

  141. 		float axisext = inputs[AXISEXT_INPUT].value;

  142. 		axisSlew = crossfade(axisext, inAxis, axisXfade);

  143. 	}else axisSlew = inAxis;

  144. 	

  145. 	float slewsum = clamp((params[AXISSLEW_PARAM].value + inputs[AXISSLEW_INPUT].value * .1f), 0.f , 1.f);

  146. 	if (slewchanged != slewsum) {

  147. 		slewchanged = slewsum;

  148. 		float slewfloat = 1.0f/(5.0f + slewsum * engineGetSampleRate());

  149. 		slewlimiter.setRiseFall(slewfloat,slewfloat);

  150. 	}

  151. 	finalAxis = slewlimiter.process(axisSlew) + (inputs[AXISSHIFT_INPUT].value * params[AXISSHIFTTRIM_PARAM].value);

  152. 	AxisShift = (static_cast<float>(axisTransParam)/12.f);

  153. 	finalAxis += clamp(AxisShift, -12.f,12.f);

  154. 	

  155. 	float range = clamp((params[XBENDRANGE_PARAM].value + inputs[XBENDRANGE_INPUT].value/2.f), 1.f,5.f);

  156. 	/////////// MOTORIZED KNOB

  157. 	//float xbend = clamp((params[XBEND_PARAM].value + (inputs[XBENDCV_INPUT].value /5.f) * (params[XBENDCVTRIM_PARAM].value /24.f)),-1.f, 1.f);

  158. 	XBenderKnobCV = (params[XBENDCVTRIM_PARAM].value / 24.f) * (inputs[XBENDCV_INPUT].value / 5.f);

  159. 	

  160. 	XBenderKnobVal = params[XBEND_PARAM].value;

  161. 	

  162. 	xbend = clamp((XBenderKnobVal + XBenderKnobCV),-1.f,1.f);

  163. 	

  164. 	/////////////////////////

  165. 	float bend = clamp((params[BEND_PARAM].value + (inputs[BENDCV_INPUT].value /5.f) * (params[BENDCVTRIM_PARAM].value /60.f)),-1.f, 1.f);

  166. 	

  167. 	for (int i = 0; i < 8; i++){

  168. 		if (inputs[IN_INPUT + i].active) {

  169. 		

  170. 			if (axisSelectTrigger[i].process(params[AXISSELECT_PARAM + i].value)) {

  171. 				selectedAxisI = i;

  172. 				selectedAxisF = static_cast<float>(i); // float for display

  173. 			}

  174. 			ioxbended[i].iactive= true;

  175. 			lights[AXIS_LIGHT + i].value = (selectedAxisI == i)? 1.f : 0.01f;

  176. 			ioxbended[i].inx = inputs[IN_INPUT + i].value;

  177. 			float diff = (finalAxis - ioxbended[i].inx) * xbend * range;

  178. 			ioxbended[i].xout = clamp((ioxbended[i].inx + diff + bend * 6.f),-12.f,12.f);

  179. 			outputs[OUT_OUTPUT + i].value = ioxbended[i].xout;

  180. 

  181. 		}else{

  182. 			lights[AXIS_LIGHT + i].value = 0;

  183. 			ioxbended[i].iactive=false;

  184. 		}

  185. 	} //for loop ix

  186.   

  187. 	outputs[AXIS_OUTPUT].value = finalAxis;

  188. 	

  189. 	if (axisTransUpTrigger.process(params[AXISTRNSUP_PARAM].value))

  190. 			if (axisTransParam < 48) axisTransParam ++;

  191. 	if (axisTransDwnTrigger.process(params[AXISTRNSDWN_PARAM].value))

  192. 			if (axisTransParam > -48) axisTransParam --;

  193.    

  194. 	bool autoZoom = (params[AUTOZOOM_PARAM].value > 0.f);

  195. 	if (autoZoom){

  196. 		frameAutoZoom ++;

  197. 		if (frameAutoZoom > 128) {

  198. 			frameAutoZoom = 0;

  199. 		float autoZoomMin = 12.f , autoZoomMax = -12.f;

  200. 			int active = 0;

  201. 		for (int i = 0; i < 8; i++){

  202. 			if (inputs[IN_INPUT + i].active) {

  203. 			active ++;

  204. 			if (ioxbended[i].inx < autoZoomMin)

  205. 				autoZoomMin = ioxbended[i].inx;

  206. 			if (ioxbended[i].xout < autoZoomMin)

  207. 				autoZoomMin = ioxbended[i].xout;

  208. 			if (ioxbended[i].inx > autoZoomMax)

  209. 				autoZoomMax = ioxbended[i].inx;

  210. 			if (ioxbended[i].xout > autoZoomMax)

  211. 				autoZoomMax = ioxbended[i].xout;

  212. 			}

  213. 		}

  214. 			if (finalAxis < autoZoomMin)

  215. 				autoZoomMin = finalAxis;

  216. 			if (finalAxis > autoZoomMax)

  217. 				autoZoomMax = finalAxis;

  218. 			float autoZ = 22.f / clamp((autoZoomMax - autoZoomMin),1.f,24.f);

  219. 			float autoCenter = 10.f * (autoZoomMin + (autoZoomMax - autoZoomMin) / 2.f);

  220. 			dZoom = clamp(autoZ, 1.f, 15.f);

  221. 			dCenter = clamp(autoCenter, -120.f, 120.f);

  222. 		}

  223. 		lights[AUTOZOOM_LIGHT].value = 10.f;

  224. 	}

  225. 	else {

  226. 		dCenter = params[XBender::YCENTER_PARAM].value;

  227. 		dZoom = params[XBender::YZOOM_PARAM].value;

  228. 		lights[AUTOZOOM_LIGHT].value = 0.f;

  229. 	}

  230. 

  231. 	testVal = xbend;

  232. }//closing STEP

  233. 

  234. ///Bend Realtime Background Display

  235. struct BenderDisplayBackG : TransparentWidget {

  236. 	BenderDisplayBackG() {

  237. 	}

  238. 	float *pyCenter ;

  239. 	float *pyZoom ;

  240. 	void draw(NVGcontext* vg)

  241. 	{

  242. 		const float dispHeight = 228.f;

  243. 		const float dispCenter = dispHeight / 2.f;

  244. 		float yZoom = *pyZoom;

  245. 		float yCenter =  *pyCenter * yZoom + dispCenter;

  246. 		float keyw = 10.f * yZoom /12.f;

  247. 		// crop drawing to display

  248. 		nvgScissor(vg, 0.f, 0.f, 152.f, dispHeight);

  249. 		nvgBeginPath(vg);

  250. 		nvgFillColor(vg, nvgRGB(0x2a, 0x2a, 0x2a));

  251. 		nvgRect(vg, 20.f, yCenter - 120.f * yZoom, 110.f, 20.f * yZoom);

  252. 		nvgRect(vg, 20.f, yCenter + 100.f * yZoom, 110.f, 20.f * yZoom);

  253. 		nvgFill(vg);

  254. 		

  255. 		nvgBeginPath(vg);

  256. 		if (yZoom > 2.5f) {

  257. 			nvgFillColor(vg, nvgRGB(0x0, 0x0, 0x0));

  258. 			nvgRect(vg, 0.f, 0.f, 20.f, dispHeight);

  259. 			nvgFill(vg);

  260. 			nvgBeginPath(vg);

  261. 			nvgFillColor(vg, nvgRGB(0x2f, 0x2f, 0x2f));

  262. 		} else {

  263. 			nvgFillColor(vg, nvgRGB(0x1a, 0x1a, 0x1a));

  264. 		}

  265. 		nvgRect(vg, 20.f, yCenter - 50.f * yZoom, 110.f, 100.f * yZoom );

  266. 		nvgFill(vg);

  267. 		for (int i = 0; i < 11; i++){

  268. 			if (yZoom < 2.5f){

  269. 			   // 1V lines

  270. 				nvgBeginPath(vg);

  271. 				nvgStrokeColor(vg, nvgRGB(0x2d,0x2d,0x2d));

  272. 				nvgMoveTo(vg, 20.f, yCenter - 10.f * yZoom * i);

  273. 				nvgLineTo(vg, 130.f,yCenter - 10.f * yZoom * i);

  274. 				nvgMoveTo(vg, 20.f, yCenter + 10.f * yZoom * i);

  275. 				nvgLineTo(vg, 130.f,yCenter + 10.f * yZoom * i);

  276. 				nvgStroke(vg);

  277. 			}else if (i < 5){

  278. 				// keyboard

  279. 				float keyPos = yCenter + 10.f * yZoom * i;

  280. 				// C's highlight

  281. 				nvgBeginPath(vg);

  282. 				nvgFillColor(vg, nvgRGB(0x44, 0x44, 0x44));

  283. 				nvgRect(vg, 20.f, yCenter - 10.f * yZoom * i - keyw * 0.5f, 110.f, keyw);

  284. 				nvgFill(vg);

  285. 				/// over center

  286. 				nvgBeginPath(vg);

  287. 				nvgFillColor(vg, nvgRGB(0x0, 0x0, 0x0));

  288. 				nvgRect(vg, 20.f, keyPos + keyw * 1.5f, 110.f, keyw);

  289. 				nvgRect(vg, 20.f, keyPos + keyw * 3.5f , 110.f, keyw);

  290. 				nvgRect(vg, 20.f, keyPos + keyw * 5.5f, 110.f, keyw);

  291. 				nvgRect(vg, 20.f, keyPos + keyw * 8.5f, 110.f, keyw);

  292. 				nvgRect(vg, 20.f, keyPos + keyw * 10.5f, 110.f, keyw);

  293. 				nvgFill(vg);

  294. 				/// C's highlight

  295. 				nvgBeginPath(vg);

  296. 				nvgFillColor(vg, nvgRGB(0x44, 0x44, 0x44));

  297. 				nvgRect(vg, 20.f, yCenter + 10.f * yZoom * i - keyw * 0.5f, 110.f, keyw);

  298. 				nvgFill(vg);

  299. 				/// under center

  300. 				keyPos = yCenter - 10.f * yZoom * i;

  301. 				nvgBeginPath(vg);

  302. 				nvgFillColor(vg, nvgRGB(0x0, 0x0, 0x0));

  303. 				nvgRect(vg, 20.f, keyPos - keyw * 1.5f, 110.f, keyw);

  304. 				nvgRect(vg, 20.f, keyPos - keyw * 3.5f , 110.f, keyw);

  305. 				nvgRect(vg, 20.f, keyPos - keyw * 6.5f, 110.f, keyw);

  306. 				nvgRect(vg, 20.f, keyPos - keyw * 8.5f, 110.f, keyw);

  307. 				nvgRect(vg, 20.f, keyPos - keyw * 10.5f, 110.f, keyw);

  308. 				nvgFill(vg);

  309. 			}

  310. 		}

  311. 		// center 0v...

  312. 		nvgBeginPath(vg);

  313. 		if (yZoom < 2.5f){

  314. 			nvgStrokeColor(vg,nvgRGBA(0x80, 0x00, 0x00 ,0x77));

  315. 			nvgStrokeWidth(vg,1.f);

  316. 			nvgMoveTo(vg, 20.f, yCenter);

  317. 			nvgLineTo(vg, 130.f, yCenter);

  318. 			nvgStroke(vg);

  319. 		 }//... center C

  320. 		 else {

  321. 			 nvgFillColor(vg, nvgRGBA(0x80, 0x00, 0x00 ,0x77));

  322. 			 nvgRect(vg, 20.f, yCenter - keyw * 0.5f, 110.f, keyw);

  323. 			 nvgFill(vg);

  324. 		}

  325. 	}

  326. };

  327. 

  328. ///Bend Realtime Display

  329. struct BenderDisplay : TransparentWidget {

  330. 	BenderDisplay() {

  331. 	}

  332. 	XBender::ioXBended *ioxB;

  333. 	

  334. 	float *pAxis =  NULL;

  335. 	float *pyCenter ;

  336. 	float *pyZoom ;

  337. 	float *pAxisIx;

  338. 	float *pAxisXfade;

  339. 	void draw(NVGcontext* vg)

  340. 	{

  341. 		const float dispHeight = 228.f;

  342. 		const float dispCenter = dispHeight / 2.f;

  343. 		float yZoom = *pyZoom;

  344. 		float yCenter =  *pyCenter * yZoom + dispCenter;

  345. 		float AxisIx = *pAxisIx;

  346. 		float keyw = 10.f * yZoom /12.f;

  347. 		// crop drawing to display

  348. 		nvgScissor(vg, 0.f, 0.f, 152.f, dispHeight);

  349. 		float Axis = *pAxis;

  350. 		///// Bend Lines

  351. 		const float yfirst = 10.5f;

  352. 		const float ystep = 26.f;

  353. 		for (int i = 0; i < 8 ; i++){

  354. 			//nowactive =;

  355. 			if (ioxB[i].iactive){

  356. 				float yport = yfirst + i * ystep;

  357. 				float yi =  yZoom * ioxB[i].inx * -10.f + yCenter ;

  358. 				float yo =  yZoom * ioxB[i].xout * -10.f + yCenter ;

  359. 				nvgBeginPath(vg);

  360. 				nvgStrokeWidth(vg,1.f);

  361. 				nvgStrokeColor(vg,nvgRGBA(0xff, 0xff, 0xff,0x80));

  362. 				nvgMoveTo(vg, 0.f, yport);

  363. 				nvgLineTo(vg, 20.f, yi);

  364. 				nvgLineTo(vg, 130.f, yo);

  365. 				nvgLineTo(vg, 150.f, yport);

  366. 				nvgStroke(vg);

  367. 				if (yZoom > 2.5f){

  368. 					nvgBeginPath(vg);

  369. 					nvgFillColor(vg, nvgRGBA(0xff, 0xff, 0xff,0x60));

  370. 					nvgRoundedRect(vg, 15.f, yi - keyw * 0.5f, 10.f, keyw, yZoom / 3.f);

  371. 					nvgFill(vg);

  372. 					nvgBeginPath(vg);

  373. 					nvgRoundedRect(vg, 125.f, yo - keyw * 0.5f, 10.f, keyw, yZoom / 3.f);

  374. 					nvgFill(vg);

  375. 				}

  376. 			}

  377. 		}

  378. 		/// Axis Line

  379. 		NVGcolor extColor = nvgRGBA(0xee, 0xee, 0x00, (1.f - *pAxisXfade) * 0xff);

  380. 		NVGcolor intColor = nvgRGBA(0xee, 0x00, 0x00, *pAxisXfade * 0xff);

  381. 		NVGcolor axisColor = nvgRGB(0xee, (1.f - *pAxisXfade) * 0xee, 0x00);

  382. 	

  383. 		Axis = yZoom * Axis * -10.f + yCenter;

  384. 		nvgStrokeWidth(vg,1.f);

  385. 	//ext

  386. 		nvgBeginPath(vg);

  387. 		nvgStrokeColor(vg,extColor);

  388. 		nvgMoveTo(vg, 0.f, 228.f);

  389. 		nvgLineTo(vg, 20.f, Axis);

  390. 		nvgStroke(vg);

  391. 	// int

  392. 		nvgBeginPath(vg);

  393. 		nvgStrokeColor(vg,intColor);

  394. 		nvgMoveTo(vg, 0.f, yfirst + AxisIx * ystep);

  395. 		nvgLineTo(vg, 20.f, Axis);

  396. 		nvgStroke(vg);

  397. 	// axis

  398. 		nvgBeginPath(vg);

  399. 		nvgStrokeColor(vg,axisColor);

  400. 		nvgMoveTo(vg, 20.f, Axis);

  401. 		nvgLineTo(vg, 130.f, Axis);

  402. 		nvgLineTo(vg, 150.f, 222.f);

  403. 		nvgStroke(vg);

  404. 	}

  405. };

  406. 

  407. // Transp Display

  408. struct AxisTranspDisplay : TransparentWidget {

  409. 	AxisTranspDisplay(){

  410. 		font = Font::load(FONT_FILE);

  411. 	}

  412. 	float mdfontSize = 11.f;

  413. 	std::string s;

  414. 	std::shared_ptr<Font> font;

  415. 	int *pAxisTransP = 0;

  416. 	int AxisTransP = 128;

  417. 	void draw(NVGcontext* vg) {

  418. 		if (AxisTransP != *pAxisTransP) {

  419. 			AxisTransP = *pAxisTransP;

  420. 			s = std::to_string(*pAxisTransP);

  421. 		}

  422. 			nvgFontSize(vg, mdfontSize);

  423. 			nvgFontFaceId(vg, font->handle);

  424. 			nvgTextAlign(vg, NVG_ALIGN_CENTER);

  425. 			nvgFillColor(vg, nvgRGB(0xFF,0xFF,0xFF));

  426. 			nvgTextBox(vg, 0.f, 14.0f,box.size.x, s.c_str(), NULL);

  427. 		}

  428. };

  429. 

  430. 

  431. struct RangeSelector: moDllzSmSelector{

  432. 	RangeSelector(){

  433. 		minAngle = -0.4*M_PI;

  434. 		maxAngle = 0.4*M_PI;

  435. 	}

  436. };

  437. 

  438. struct xbendKnob : SVGKnob {

  439. //	 XBender *module;

  440. //	float *ptoKnobCV = 0;

  441. //	float *pxbend = 0;

  442. //

  443. //	float toKnobCV = 0.f;

  444. //	float KnobVal = 0.f;

  445. 

  446. 	xbendKnob() {

  447. 		minAngle = -0.83*M_PI;

  448. 		maxAngle = 0.83*M_PI;

  449. 		setSVG(SVG::load(assetPlugin(plugin, "res/xbendKnob.svg")));

  450. 		shadow->opacity = 0.f;

  451. 	}

  452. //	void step() {

  453. //		if (KnobVal != *pxbend){

  454. //			KnobVal = *pxbend;

  455. //			toKnobCV = *ptoKnobCV;

  456. //			value = KnobVal;

  457. //			dirty = true;

  458. //		}

  459. //		if (dirty) {

  460. //			float angle;

  461. //			if (isfinite(minValue) && isfinite(maxValue)) {

  462. //				angle = rescale(value, minValue, maxValue, minAngle, maxAngle);

  463. //			}

  464. //			else {

  465. //				angle = rescale(value, -1.0, 1.0, minAngle, maxAngle);

  466. //				angle = fmodf(angle, 2*M_PI);

  467. //			}

  468. //			tw->identity();

  469. //			// Rotate SVG

  470. //			Vec center = sw->box.getCenter();

  471. //			tw->translate(center);

  472. //			tw->rotate(angle);

  473. //			tw->translate(center.neg());

  474. //			// Redraw

  475. //			module->XBenderKnobVal = value - toKnobCV;

  476. //		}

  477. //		FramebufferWidget::step();

  478. //	}

  479. //

  480. //	void onChange(EventChange &e) {

  481. //		dirty = true;

  482. //		Knob::onChange(e);

  483. //	}

  484. //	void onMouseUp(EventMouseUp &e){

  485. //

  486. //	}

  487. };

  488. 

  489. struct zTTrim : SVGKnob {

  490. 	zTTrim() {

  491. 		minAngle = 0;

  492. 		maxAngle = 1.75*M_PI;

  493. 		setSVG(SVG::load(assetPlugin(plugin, "res/zTTrim.svg")));

  494. 		shadow->opacity = 0.f;

  495. 	}

  496. };

  497. 

  498. struct cTTrim : SVGKnob {

  499. 	cTTrim() {

  500. 		minAngle = -0.83*M_PI;

  501. 		maxAngle = 0.83*M_PI;

  502. 		snap = true;

  503. 		setSVG(SVG::load(assetPlugin(plugin, "res/cTTrim.svg")));

  504. 		shadow->opacity = 0.f;

  505. 	}

  506. };

  507. 

  508. struct autoZoom : SVGSwitch, ToggleSwitch {

  509. 	autoZoom() {

  510. 		addFrame(SVG::load(assetPlugin(plugin, "res/autoButton.svg")));

  511. 		addFrame(SVG::load(assetPlugin(plugin, "res/autoButton.svg")));

  512. 	}

  513. };

  514. 

  515. struct snapAxisButton : SVGSwitch, ToggleSwitch {

  516.   snapAxisButton() {

  517. 	  addFrame(SVG::load(assetPlugin(plugin, "res/snapButton.svg")));

  518. 	  addFrame(SVG::load(assetPlugin(plugin, "res/snapButton.svg")));

  519.   }

  520. };

  521. 

  522. 

  523. struct XBenderWidget : ModuleWidget {

  524. 	

  525. 		XBenderWidget(XBender *module): ModuleWidget(module){

  526. 		setPanel(SVG::load(assetPlugin(plugin, "res/XBender.svg")));

  527. 		float xPos;

  528. 		float yPos;

  529. 		float xyStep = 26.f ;

  530. 		//Screws

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

  532. 		addChild(Widget::create<ScrewBlack>(Vec(box.size.x - 15, 0)));

  533. 		addChild(Widget::create<ScrewBlack>(Vec(0, 365)));

  534. 		addChild(Widget::create<ScrewBlack>(Vec(box.size.x - 15, 365)));

  535. 		

  536. 		xPos = 73.f;

  537. 		yPos = 22.f;

  538. 		{

  539. 			BenderDisplayBackG *benderDisplayBG = new BenderDisplayBackG();

  540. 			benderDisplayBG->box.pos = Vec(xPos, yPos);

  541. 			benderDisplayBG->box.size = {152.f, 228.f};

  542. 			benderDisplayBG->pyCenter = &(module->dCenter);

  543. 			benderDisplayBG->pyZoom = &(module->dZoom);

  544. 			addChild(benderDisplayBG);

  545. 		}

  546. 		

  547. 		{

  548. 			BenderDisplay *benderDisplay = new BenderDisplay();

  549. 			benderDisplay->box.pos = Vec(xPos, yPos);

  550. 			benderDisplay->box.size = {152.f, 228.f};

  551. 			benderDisplay->ioxB = &(module->ioxbended[0]);

  552. 			benderDisplay->pAxis = &(module->finalAxis);

  553. 			benderDisplay->pAxisIx = &(module->selectedAxisF);

  554. 			benderDisplay->pyCenter = &(module->dCenter);

  555. 			benderDisplay->pyZoom = &(module->dZoom);

  556. 			benderDisplay->pAxisXfade = &(module->axisXfade);

  557. 			addChild(benderDisplay);

  558. 		}

  559. 		

  560. 		xPos = 170.f;

  561. 		yPos = 252.f;

  562. 		/// View Center Zoom

  563. 		addParam(ParamWidget::create<cTTrim>(Vec(xPos,yPos), module, XBender::YCENTER_PARAM, -120.f, 120.f, 0.f));

  564. 		xPos = 203;

  565. 		addParam(ParamWidget::create<zTTrim>(Vec(xPos,yPos), module, XBender::YZOOM_PARAM, 1.f, 15.f, 1.f));

  566. 		yPos += 1.5f;

  567. 		xPos = 125.f;

  568. 		addParam(ParamWidget::create<autoZoom>(Vec(xPos, yPos ), module, XBender::AUTOZOOM_PARAM, 0.0f, 1.0f, 1.0f));

  569. 		addChild(ModuleLightWidget::create<TinyLight<RedLight>>(Vec(xPos + 17.f, yPos + 4.f), module, XBender::AUTOZOOM_LIGHT));

  570. 

  571. 		/// IN  - Axis select  - OUTS

  572. 		xPos = 12.f;

  573. 		yPos = 22.f;

  574. 		for (int i = 0; i < 8; i++){

  575. 			// IN leds  OUT

  576. 			addInput(Port::create<moDllzPort>(Vec(xPos, yPos), Port::INPUT, module, XBender::IN_INPUT + i));

  577. 			addParam(ParamWidget::create<moDllzRoundButton>(Vec(xPos + 37.f, yPos + 5.f), module, XBender::AXISSELECT_PARAM + i, 0.0f, 1.0f, 0.0f));

  578. 			addChild(ModuleLightWidget::create<TinyLight<RedLight>>(Vec(xPos + 42.5f, yPos + 10.5f), module, XBender::AXIS_LIGHT + i));

  579. 			addOutput(Port::create<moDllzPort>(Vec(234.8f, yPos), Port::OUTPUT, module, XBender::OUT_OUTPUT + i));

  580. 			yPos += xyStep;

  581. 		}

  582. 		yPos = 248.f;

  583. 		//// AXIS out >>>> on the Right

  584. 		addOutput(Port::create<moDllzPort>(Vec(234.8f, yPos), Port::OUTPUT, module, XBender::AXIS_OUTPUT));

  585. 		

  586. 		yPos = 249.f;

  587. 		/// AXIS select in

  588. 		addInput(Port::create<moDllzPort>(Vec(xPos, yPos), Port::INPUT, module, XBender::AXISSELECT_INPUT));

  589. 		addParam(ParamWidget::create<snapAxisButton>(Vec(xPos + 22.5f, yPos + 2.f ), module, XBender::SNAPAXIS_PARAM, 0.0f, 1.0f, 0.0f));

  590. 		addChild(ModuleLightWidget::create<TinyLight<RedLight>>(Vec(xPos + 40.f, yPos + 4.f), module, XBender::SNAPAXIS_LIGHT));

  591. 

  592. 		/// AXIS EXT - XFADE

  593. 		yPos += 25.f;

  594. 		addInput(Port::create<moDllzPort>(Vec(xPos, yPos), Port::INPUT, module, XBender::AXISXFADE_INPUT));

  595. 		addParam(ParamWidget::create<moDllzKnob26>(Vec(36.f,280.f), module, XBender::AXISXFADE_PARAM, 0.f, 1.f, 1.f));

  596. 		yPos += 25.f;

  597. 		addInput(Port::create<moDllzPort>(Vec(xPos, yPos), Port::INPUT, module, XBender::AXISEXT_INPUT));

  598. 			

  599. 		/// AXIS Slew

  600. 		yPos += 25.f;

  601. 		addInput(Port::create<moDllzPort>(Vec(xPos, yPos), Port::INPUT, module, XBender::AXISSLEW_INPUT));

  602. 		addParam(ParamWidget::create<moDllzKnob26>(Vec(34.f, 324.f), module, XBender::AXISSLEW_PARAM, 0.f, 1.f, 0.f));

  603.  

  604. 		//AXIS Mod Shift

  605. 		addInput(Port::create<moDllzPort>(Vec(xPos + 53.f,yPos), Port::INPUT, module, XBender::AXISSHIFT_INPUT));

  606. 		addParam(ParamWidget::create<moDllzKnob26>(Vec(87.f, 324.f), module, XBender::AXISSHIFTTRIM_PARAM, 0.0f, 1.0f, 0.f));

  607. 

  608. 		//AXIS Transp

  609. 		xPos = 73.5f;

  610. 		yPos = 278.5f;

  611. 		addParam(ParamWidget::create<moDllzPulseUp>(Vec(xPos + 31.f,yPos - 1.f), module, XBender::AXISTRNSUP_PARAM, 0.0f, 1.0f, 0.0f));

  612. 		addParam(ParamWidget::create<moDllzPulseDwn>(Vec(xPos + 31.f ,yPos + 10.f), module, XBender::AXISTRNSDWN_PARAM, 0.0f, 1.0f, 0.0f));

  613. 		{

  614. 			AxisTranspDisplay *axisTranspDisplay = new AxisTranspDisplay();

  615. 			axisTranspDisplay->box.pos = Vec(xPos, yPos);

  616. 			axisTranspDisplay->box.size = {30.f, 20};

  617. 			axisTranspDisplay->pAxisTransP = &(module->axisTransParam);

  618. 			addChild(axisTranspDisplay);

  619. 		}

  620. 		/// Knobs

  621. 		

  622. 		//XBEND

  623. 		xPos = 124.f;

  624. 		yPos = 272.f;

  625. 		

  626. 		addParam(ParamWidget::create<xbendKnob>(Vec(xPos, yPos), module, XBender::XBEND_PARAM, -1.f, 1.f, 0.f));

  627. //			{   xbendKnob *xbendK = new xbendKnob();

  628. //				xbendK->box.pos = Vec(xPos, yPos);

  629. //				xbendK->box.size = {50.f, 50.f};

  630. //				xbendK->minValue = -1.f;

  631. //				xbendK->maxValue = 1.f;

  632. //				xbendK->defaultValue = 0.f;

  633. //				xbendK->module = module;

  634. //				xbendK->ptoKnobCV = &(module->XBenderKnobCV);

  635. //				xbendK->pxbend = &(module->xbend);

  636. //				addChild(xbendK);

  637. //			}

  638. 		xPos = 127.5f;

  639. 		yPos = 328.f;

  640. 		addInput(Port::create<moDllzPort>(Vec(xPos,yPos), Port::INPUT, module, XBender::XBENDCV_INPUT));

  641. 		addParam(ParamWidget::create<TTrimSnap>(Vec(xPos + 26.5f,yPos + 7.f), module, XBender::XBENDCVTRIM_PARAM, 0.f, 24.f, 24.f));

  642. 			

  643. 		xPos = 127.5f;

  644. 		yPos = 328.f;

  645. 		addInput(Port::create<moDllzPort>(Vec(xPos,yPos), Port::INPUT, module, XBender::XBENDCV_INPUT));

  646. 		addParam(ParamWidget::create<TTrimSnap>(Vec(xPos + 26.5f,yPos + 7.f), module, XBender::XBENDCVTRIM_PARAM, 0.f, 24.f, 24.f));

  647. 		//XBEND RANGE

  648. 		xPos = 181.f;

  649. 		yPos = 288.f;

  650. 		addParam(ParamWidget::create<RangeSelector>(Vec(xPos, yPos), module, XBender::XBENDRANGE_PARAM, 1.f, 5.f, 1.f));

  651. 		xPos = 187.5f;

  652. 		yPos = 328.f;

  653. 		addInput(Port::create<moDllzPort>(Vec(xPos,yPos), Port::INPUT, module, XBender::XBENDRANGE_INPUT));

  654. 		//BEND

  655. 		xPos = 219.f;

  656. 		yPos = 288.f;

  657. 		addParam(ParamWidget::create<moDllzKnobM>(Vec(xPos, yPos), module, XBender::BEND_PARAM, -1.f, 1.f, 0.f));

  658. 		xPos = 218.5f;

  659. 		yPos = 328.f;

  660. 		addInput(Port::create<moDllzPort>(Vec(xPos,yPos), Port::INPUT, module, XBender::BENDCV_INPUT));

  661. 		addParam(ParamWidget::create<TTrimSnap>(Vec(xPos + 26.5f,yPos + 7.f), module, XBender::BENDCVTRIM_PARAM, 0.f, 60.f, 12.f));

  662. //		{

  663. //			testDisplay *mDisplay = new testDisplay();

  664. //			mDisplay->box.pos = Vec(0.0f, 360.0f);

  665. //			mDisplay->box.size = {165.0f, 20.0f};

  666. //			mDisplay->valP = &(module->testVal);

  667. //			addChild(mDisplay);

  668. //		}

  669. 			

  670. 	}

  671. };

  672. 

  673. // Specify the Module and ModuleWidget subclass, human-readable

  674. // manufacturer name for categorization, module slug (should never

  675. // change), human-readable module name, and any number of tags

  676. // (found in `include/tags.hpp`) separated by commas.

  677. 

  678. } // namespace rack_plugin_moDllz

  679. 

  680. using namespace rack_plugin_moDllz;

  681. 

  682. RACK_PLUGIN_MODEL_INIT(moDllz, XBender) {

  683.    Model *modelXBender = Model::create<XBender, XBenderWidget>("moDllz", "XBender", "Poly X Bender",MULTIPLE_TAG ,EFFECT_TAG);

  684.    return modelXBender;

  685. }