non
/
spiralsynthmodular
mirror of https://github.com/original-male/spiralsynthmodular
1
0
Fork 0
Code Releases 0 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.
146 Commits
1 Branch
1.8MB
Tree: ecab653ae2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ecab653ae2'
${ noResults }
spiralsynthmodular/SpiralSound/Plugins/MatrixPlugin/MatrixPlugin.C

501 lines
11KB
Raw Blame History 

  1. /*  SpiralSound

  2.  *  Copyleft (C) 2001 David Griffiths <dave@pawfal.org>

  3.  *

  4.  *  This program is free software; you can redistribute it and/or modify

  5.  *  it under the terms of the GNU General Public License as published by

  6.  *  the Free Software Foundation; either version 2 of the License, or

  7.  *  (at your option) any later version.

  8.  *

  9.  *  This program is distributed in the hope that it will be useful,

  10.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of

  11.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  12.  *  GNU General Public License for more details.

  13.  *

  14.  *  You should have received a copy of the GNU General Public License

  15.  *  along with this program; if not, write to the Free Software

  16.  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

  17. */

  18. #include "MatrixPlugin.h"

  19. #include "MatrixPluginGUI.h"

  20. #include <FL/Fl_Button.h>

  21. #include "SpiralIcon.xpm"

  22. #include "../../RiffWav.h"

  23. #include "../../NoteTable.h"

  24. 

  25. extern "C" {

  26. SpiralPlugin* CreateInstance()

  27. {

  28. 	return new MatrixPlugin;

  29. }

  30. 

  31. char** GetIcon()

  32. {

  33. 	return SpiralIcon_xpm;

  34. }

  35. 

  36. int GetID()

  37. {

  38. 	return 0x0012;

  39. }

  40. 

  41. string GetGroupName()

  42. {

  43. 	return "SpiralSound";

  44. }

  45. }

  46. 

  47. ///////////////////////////////////////////////////////

  48. 

  49. MatrixPlugin::MatrixPlugin() :

  50. m_TickTime(1.0f),

  51. m_StepTime(1.0f),

  52. m_Time(0.0f),

  53. m_Step(0),

  54. m_Loop(true),

  55. m_NoteCut(false),

  56. m_Current(0),

  57. m_GUICurrent(0),

  58. m_CurrentNoteCV(0),

  59. m_CurrentTriggerCV(0),

  60. m_Triggered(false),

  61. m_ClockHigh(false),

  62. m_CopyPattern(0),

  63. m_PatAdvance(false),

  64. m_PatReset(false)

  65. {

  66. 	m_Version=3;

  67. 

  68. 	m_PluginInfo.Name="Matrix";

  69. 	m_PluginInfo.Width=560;

  70. 	m_PluginInfo.Height=270;

  71. 	m_PluginInfo.NumInputs=5;

  72. 	m_PluginInfo.NumOutputs=19;		

  73. 	m_PluginInfo.PortTips.push_back("Play Trigger");	

  74. 	m_PluginInfo.PortTips.push_back("StepTime CV");	

  75. 	m_PluginInfo.PortTips.push_back("Input Pitch CV");	

  76. 	m_PluginInfo.PortTips.push_back("Input Trigger CV");

  77. 	m_PluginInfo.PortTips.push_back("External Clock");

  78. 	//m_PluginInfo.PortTips.push_back("Pattern Advance");

  79. 	//m_PluginInfo.PortTips.push_back("Pattern Reset");

  80. 	m_PluginInfo.PortTips.push_back("Output Pitch");	

  81. 	m_PluginInfo.PortTips.push_back("Output Trigger");

  82. 	m_PluginInfo.PortTips.push_back("Trigger 1");

  83. 	m_PluginInfo.PortTips.push_back("Trigger 2");

  84. 	m_PluginInfo.PortTips.push_back("Trigger 3");

  85. 	m_PluginInfo.PortTips.push_back("Trigger 4");

  86. 	m_PluginInfo.PortTips.push_back("Trigger 5");

  87. 	m_PluginInfo.PortTips.push_back("Trigger 6");

  88. 	m_PluginInfo.PortTips.push_back("Trigger 7");

  89. 	m_PluginInfo.PortTips.push_back("Trigger 8");

  90. 	m_PluginInfo.PortTips.push_back("Trigger 9");

  91. 	m_PluginInfo.PortTips.push_back("Trigger 10");

  92. 	m_PluginInfo.PortTips.push_back("Trigger 11");

  93. 	m_PluginInfo.PortTips.push_back("Trigger 12");

  94. 	m_PluginInfo.PortTips.push_back("Trigger 13");

  95. 	m_PluginInfo.PortTips.push_back("Trigger 14");

  96. 	m_PluginInfo.PortTips.push_back("Trigger 15");

  97. 	m_PluginInfo.PortTips.push_back("Trigger 16");

  98. 	m_PluginInfo.PortTips.push_back("Reset Trigger");	

  99. 		

  100. 	for (int n=0; n<NUM_PATTERNS; n++)

  101. 	{

  102. 		m_Matrix[n].Length=64;

  103. 		m_Matrix[n].Speed=1.0f;

  104. 		m_Matrix[n].Octave=0;

  105. 		

  106. 		for (int x=0; x<MATX; x++)

  107. 		for (int y=0; y<MATY; y++)

  108. 		{

  109. 			m_Matrix[n].Matrix[x][y]=false;

  110. 			m_Matrix[n].Volume[x][y]=1;

  111. 		}

  112. 		

  113. 		m_TriggerLevel[n]=0;

  114. 	}

  115. 	

  116. 	m_AudioCH->Register("NoteCut",&m_NoteCut,ChannelHandler::INPUT);

  117. 	m_AudioCH->Register("Volume",&m_GUIArgs.Volume,ChannelHandler::INPUT);

  118. 	m_AudioCH->Register("Current",&m_GUICurrent,ChannelHandler::INPUT);

  119. 	m_AudioCH->Register("StepTime",&m_StepTime,ChannelHandler::INPUT);

  120. 	m_AudioCH->Register("Num",&m_GUIArgs.Num,ChannelHandler::INPUT);

  121. 	m_AudioCH->Register("Length",&m_GUIArgs.Length,ChannelHandler::INPUT);

  122. 	m_AudioCH->Register("Speed",&m_GUIArgs.Speed,ChannelHandler::INPUT);

  123. 	m_AudioCH->Register("X",&m_GUIArgs.X,ChannelHandler::INPUT);

  124. 	m_AudioCH->Register("Y",&m_GUIArgs.Y,ChannelHandler::INPUT);

  125. 	m_AudioCH->Register("Octave",&m_GUIArgs.Octave,ChannelHandler::INPUT);

  126. 	m_AudioCH->Register("Step",&m_Step,ChannelHandler::OUTPUT);

  127. 	m_AudioCH->RegisterData("Matrix",ChannelHandler::OUTPUT_REQUEST,&m_Matrix,sizeof(m_Matrix));

  128. }

  129. 

  130. MatrixPlugin::~MatrixPlugin()

  131. {

  132. }

  133. 

  134. PluginInfo &MatrixPlugin::Initialise(const HostInfo *Host)

  135. {	

  136. 	PluginInfo& Info = SpiralPlugin::Initialise(Host);

  137. 	m_TickTime = 1.0f/(float)m_HostInfo->SAMPLERATE;

  138. 	return Info;

  139. }

  140. 

  141. SpiralGUIType *MatrixPlugin::CreateGUI()

  142. {

  143. 	return new MatrixPluginGUI(m_PluginInfo.Width,

  144. 								  	    m_PluginInfo.Height,

  145. 										this,m_AudioCH,m_HostInfo);

  146. }

  147. 

  148. void MatrixPlugin::Execute()

  149. {	

  150. 	for (int n=0; n<m_HostInfo->BUFSIZE; n++)

  151. 	{

  152. 		if (InputExists(1)) m_StepTime = GetInput(1,n);

  153. 		

  154. 		// inc time 

  155. 		m_Time+=m_TickTime;

  156. 		

  157. 		SetOutputPitch(0,n,m_CurrentNoteCV);

  158. 		SetOutput(1,n,m_CurrentTriggerCV);

  159.                 

  160. 		// clear the pattern sync

  161.         SetOutput(18, n, 0);

  162. 		

  163. 		bool ExternalClock = InputExists(4);

  164. 		bool ExternalClockTriggered=false;

  165. 		 

  166. 		if (GetInputPitch(0,n)>0) 

  167. 		{

  168. 			if (!m_Triggered)

  169. 			{

  170. 				float Freq=GetInputPitch(0,n);

  171. 				// Notes 0 to 16 trigger patterns 0 to 16

  172. 				// No other notes catered for

  173. 				for (int i=0; i<NUM_PATTERNS; i++)

  174. 				{

  175. 					if (feq(Freq,NoteTable[i],0.01f))

  176. 					{						

  177. 						m_Current=i;

  178. 						break;

  179. 					}

  180. 				}

  181. 				

  182. 				// make it so the next note to trigger

  183. 				// will be the first one								

  184. 				m_Time=m_StepTime*(1/m_Matrix[m_Current].Speed);

  185. 				m_Step=-1;

  186. 				ExternalClockTriggered=true;

  187. 				m_Triggered=true;

  188. 			}

  189. 		}

  190. 		else

  191. 		{

  192. 			m_Triggered=false;

  193. 		}

  194. 

  195. 

  196. 		// set the individual triggers

  197. 		for (int t=0; t<NUM_PATTERNS; t++) SetOutput(t+2,n,m_TriggerLevel[t]);

  198. 		

  199. 		if (ExternalClock)

  200. 		{

  201. 			if (GetInput(4,n)>0)

  202. 			{

  203. 				if(!m_ClockHigh)

  204. 				{

  205. 					m_ClockHigh=true;

  206. 					ExternalClockTriggered=true;

  207. 				}

  208. 			}

  209. 			else

  210. 			{

  211. 				if (m_ClockHigh)

  212. 				{

  213. 					m_ClockHigh=false;

  214. 					ExternalClockTriggered=true;

  215. 				}

  216. 			}

  217. 			

  218. 			// reset the position on a signal from input 1

  219. 			if (InputExists(0) && GetInput(0,n)!=0)

  220. 			{

  221. 				m_Step=-1;

  222. 				ExternalClockTriggered=true;

  223. 			}

  224. 		}

  225. /* not yet...			

  226. 		// external pattern advance

  227. 		if (GetInput(5,n)>0)

  228. 		{

  229. 			if (!m_PatAdvance)

  230. 			{

  231. 				m_Current++;

  232. 				if (m_Current==16) m_Current=0;

  233. 				m_PatAdvance=true;

  234. 				m_Step=-1;

  235. 				ExternalClockTriggered=true;

  236. 			}

  237. 		}

  238. 		else

  239. 		{

  240. 			m_PatAdvance=false;

  241. 		}

  242. 		

  243. 		// external pattern reset

  244. 		if (GetInput(6,n)>0)

  245. 		{

  246. 			if (!m_PatReset)

  247. 			{

  248. 				m_Current=0;

  249. 				m_PatReset=true;

  250. 				m_Step=-1;

  251. 				ExternalClockTriggered=true;

  252. 			}

  253. 		}

  254. 		else

  255. 		{

  256. 			m_PatReset=false;

  257. 		}	

  258. */		

  259. 		// An external clock pulse overrides the internal timing

  260. 		if ((!ExternalClock && m_Time>=m_StepTime*(1/m_Matrix[m_Current].Speed)) ||

  261. 			(ExternalClock && ExternalClockTriggered)) 

  262. 		{		

  263. 			m_Time=0;

  264. 			m_Step++;

  265. 			

  266. 			

  267. 			if (m_Step >= m_Matrix[m_Current].Length) 

  268. 			{

  269. 				SetOutput(18, n, 1);

  270. 				m_Step=0;

  271. 			}

  272. 						

  273. 			// Reset the values

  274. 			m_CurrentTriggerCV=0;

  275. 			if (m_NoteCut) m_CurrentNoteCV=0;

  276. 			for (int t=0; t<NUM_PATTERNS; t++) 

  277. 			{

  278. 				SetOutput(t+2,n,0);

  279. 				m_TriggerLevel[t]=0;

  280. 			}

  281. 			

  282. 			// Scan the matrix at current time 

  283. 			for (int i=0; i<MATY; i++)

  284. 			{

  285. 				if (m_Matrix[m_Current].Matrix[m_Step][i])

  286. 				{

  287. 				

  288. 					m_CurrentNoteCV=NoteTable[i+m_Matrix[m_Current].Octave*12];

  289. 					m_CurrentTriggerCV=m_Matrix[m_Current].Volume[m_Step][i];

  290. 					m_TriggerLevel[i]=m_Matrix[m_Current].Volume[m_Step][i];

  291. 				}

  292. 			}

  293. 			

  294. 			// reset the triggers between steps to clear them

  295. 			// otherwise consecutive events wont get triggered

  296. 			SetOutput(1,n,0);

  297. 			for (int t=0; t<NUM_PATTERNS; t++) SetOutput(t+2,n,0);

  298. 		}

  299. 	}

  300. }

  301. 

  302. void MatrixPlugin::ExecuteCommands()

  303. {

  304. 	if (m_AudioCH->IsCommandWaiting())

  305. 	{

  306. 		switch (m_AudioCH->GetCommand())

  307. 		{

  308. 			case MAT_LENGTH   :

  309. 				m_Matrix[m_GUICurrent].Length=m_GUIArgs.Length; 

  310. 			break;

  311. 			

  312. 			case MAT_SPEED    : 

  313. 				m_Matrix[m_GUICurrent].Speed=m_GUIArgs.Speed; 

  314. 			break;		

  315. 			

  316. 			case MAT_ACTIVATE : 

  317. 				m_Matrix[m_GUICurrent].Matrix[m_GUIArgs.X][m_GUIArgs.Y]=true; 

  318. 			break;		

  319. 			

  320. 			case MAT_DEACTIVATE : 

  321. 				m_Matrix[m_GUICurrent].Matrix[m_GUIArgs.X][m_GUIArgs.Y]=false; 

  322. 			break;

  323. 			case MAT_OCTAVE : 

  324. 				m_Matrix[m_GUICurrent].Octave=m_GUIArgs.Octave; 

  325. 			break;

  326. 			case COPY : 

  327. 				CopyPattern(); 

  328. 			break;

  329. 			case PASTE : 

  330. 				PastePattern(); 

  331. 			break;

  332. 			case CLEAR : 

  333. 				ClearPattern(); 

  334. 			break;

  335. 			case TUP : 

  336. 				if (CanTransposeUp()) TransposeUp(); 

  337. 			break;

  338. 			case TDOWN : 

  339. 				if (CanTransposeDown()) TransposeDown(); 

  340. 			break;

  341. 			case MAT_VOLUME : 

  342. 				m_Matrix[m_GUICurrent].Volume[m_GUIArgs.X][m_GUIArgs.Y]=m_GUIArgs.Volume; 

  343. 			break;

  344. 			case SET_CURRENT : 

  345. 				m_Current=m_GUIArgs.Num; 

  346. 			break;

  347. 		}

  348. 	}

  349. }

  350. 

  351. void MatrixPlugin::PastePattern() {

  352.      m_Matrix[m_GUICurrent].Length = m_Matrix[m_CopyPattern].Length;

  353.      m_Matrix[m_GUICurrent].Speed = m_Matrix[m_CopyPattern].Speed;

  354.      m_Matrix[m_GUICurrent].Octave = m_Matrix[m_CopyPattern].Octave;

  355.      for (int y=0; y<MATY; y++) {

  356.          for (int x=0; x<MATX; x++) {

  357.              m_Matrix[m_GUICurrent].Matrix[x][y] = m_Matrix[m_CopyPattern].Matrix[x][y];

  358.          }

  359.      }

  360. }

  361. 

  362. void MatrixPlugin::ClearPattern() {

  363.      for (int y=0; y<MATY; y++) {

  364.          for (int x=0; x<MATX; x++) {

  365.              m_Matrix[m_GUICurrent].Matrix[x][y] = 0;

  366.          }

  367.      }

  368. }

  369. 

  370. void MatrixPlugin::TransposeUp() {

  371.      int x, y;

  372.      for (y=MATY-1; y>=0; y--) {

  373.          for (x=0; x<MATX; x++) {

  374.              m_Matrix[m_GUICurrent].Matrix[x][y] = m_Matrix[m_GUICurrent].Matrix[x][y-1];

  375.          }

  376.      }

  377.      for (x=0; x<MATX; x++) {

  378.          m_Matrix[m_GUICurrent].Matrix[x][0] = 0;

  379.      }

  380. }

  381. 

  382. void MatrixPlugin::TransposeDown() 

  383. {

  384.     int x, y;

  385.     for (y=0; y<MATY-1; y++) 

  386. 	{

  387.         for (x=0; x<MATX; x++) 

  388. 		{

  389.             m_Matrix[m_GUICurrent].Matrix[x][y] = m_Matrix[m_GUICurrent].Matrix[x][y+1];

  390.         }

  391.     }

  392.     for (x=0; x<MATX; x++) 

  393. 	{

  394.     	m_Matrix[m_GUICurrent].Matrix[x][MATY-1] = 0;

  395.     }

  396. }

  397. 

  398. bool MatrixPlugin::CanTransposeDown() 

  399. {

  400.     for (int x=0; x<MATX; x++) if (m_Matrix[m_GUICurrent].Matrix[x][0]) return False;

  401.     return True;

  402. }

  403. 

  404. bool MatrixPlugin::CanTransposeUp() 

  405. {

  406.      for (int x=0; x<MATX; x++) if (m_Matrix[m_Current].Matrix[x][MATY-1]) return False;

  407.      return True;

  408. }

  409. 

  410. void MatrixPlugin::StreamOut(ostream &s)

  411. {

  412. 	s<<m_Version<<" ";

  413. 	s<<m_Current<<" "<<m_Time<<" "<<m_Step<<" "<<m_Loop<<" "<<m_NoteCut<<" "<<endl;

  414. 	

  415. 	for (int n=0; n<NUM_PATTERNS; n++)	

  416. 	{

  417. 		s<<m_Matrix[n].Length<<" "<<m_Matrix[n].Speed<<" "<<m_Matrix[n].Octave<<endl;

  418. 		

  419. 		for (int y=0; y<MATY; y++)

  420. 		{

  421. 			for (int x=0; x<MATX; x++)

  422. 			{

  423. 				if (m_Matrix[n].Matrix[x][y]) s<<x<<" "<<y<<"  "<<m_Matrix[n].Volume[x][y]<<" ";

  424. 			}

  425. 		}

  426. 		s<<"-1 ";

  427. 	}

  428. }

  429. 

  430. void MatrixPlugin::StreamIn(istream &s)

  431. {

  432. 	int version;

  433. 	s>>version;

  434. 	

  435. 	switch (version)

  436. 	{

  437. 		case 1:

  438. 		{

  439. 			s>>m_Current>>m_Time>>m_Step>>m_Loop>>m_NoteCut;

  440. 	

  441. 			for (int n=0; n<NUM_PATTERNS; n++)	

  442. 			{	

  443. 				s>>m_Matrix[n].Length>>m_Matrix[n].Speed>>m_Matrix[n].Octave;

  444. 		

  445. 				for (int y=0; y<MATY; y++)

  446. 				for (int x=0; x<MATX; x++)

  447. 				{

  448. 					s>>m_Matrix[n].Matrix[x][y];

  449. 				}

  450. 			}

  451. 		} break;

  452. 	

  453. 		case 2:

  454. 		{

  455. 			s>>m_Current>>m_Time>>m_Step>>m_Loop>>m_NoteCut;

  456. 	

  457. 			for (int n=0; n<NUM_PATTERNS; n++)	

  458. 			{	

  459. 				s>>m_Matrix[n].Length>>m_Matrix[n].Speed>>m_Matrix[n].Octave;

  460. 		

  461. 				int x=0,y=0;

  462. 				while(x!=-1)

  463. 				{

  464. 					s>>x;

  465. 					if (x!=-1)

  466. 					{						

  467. 						s>>y;

  468. 						if (y!=-1) m_Matrix[n].Matrix[x][y]=true;

  469. 					}

  470. 				}

  471. 			}

  472. 		} break;

  473. 		

  474. 		case 3:

  475. 		{

  476. 			s>>m_Current>>m_Time>>m_Step>>m_Loop>>m_NoteCut;

  477. 	

  478. 			for (int n=0; n<NUM_PATTERNS; n++)	

  479. 			{	

  480. 				s>>m_Matrix[n].Length>>m_Matrix[n].Speed>>m_Matrix[n].Octave;

  481. 		

  482. 				int x=0,y=0;

  483. 				float v;

  484. 				while(x!=-1)

  485. 				{

  486. 					s>>x;

  487. 					if (x!=-1)

  488. 					{						

  489. 						s>>y>>v;

  490. 						if (y!=-1) 

  491. 						{

  492. 							m_Matrix[n].Matrix[x][y]=true;

  493. 							m_Matrix[n].Volume[x][y]=v;

  494. 						}

  495. 					}

  496. 				}

  497. 			}

  498. 		} break;

  499. 	}

  500. }