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.
99 Commits
1 Branch
1.8MB
Tree: 3c6be46311
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3c6be46311'
${ noResults }
spiralsynthmodular/SpiralSound/Plugins/MatrixPlugin/MatrixPlugin.C

496 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. 

  42. ///////////////////////////////////////////////////////

  43. 

  44. MatrixPlugin::MatrixPlugin() :

  45. m_TickTime(1.0f),

  46. m_StepTime(1.0f),

  47. m_Time(0.0f),

  48. m_Step(0),

  49. m_Loop(true),

  50. m_NoteCut(false),

  51. m_Current(0),

  52. m_GUICurrent(0),

  53. m_CurrentNoteCV(0),

  54. m_CurrentTriggerCV(0),

  55. m_Triggered(false),

  56. m_ClockHigh(false),

  57. m_CopyPattern(0),

  58. m_PatAdvance(false),

  59. m_PatReset(false)

  60. {

  61. 	m_Version=3;

  62. 

  63. 	m_PluginInfo.Name="Matrix";

  64. 	m_PluginInfo.Width=560;

  65. 	m_PluginInfo.Height=270;

  66. 	m_PluginInfo.NumInputs=5;

  67. 	m_PluginInfo.NumOutputs=19;		

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  94. 		

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

  96. 	{

  97. 		m_Matrix[n].Length=64;

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

  99. 		m_Matrix[n].Octave=0;

  100. 		

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

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

  103. 		{

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

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

  106. 		}

  107. 		

  108. 		m_TriggerLevel[n]=0;

  109. 	}

  110. 	

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

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

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

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

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

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

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

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

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

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

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

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

  123. }

  124. 

  125. MatrixPlugin::~MatrixPlugin()

  126. {

  127. }

  128. 

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

  130. {	

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

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

  133. 	return Info;

  134. }

  135. 

  136. SpiralGUIType *MatrixPlugin::CreateGUI()

  137. {

  138. 	return new MatrixPluginGUI(m_PluginInfo.Width,

  139. 								  	    m_PluginInfo.Height,

  140. 										this,m_AudioCH,m_HostInfo);

  141. }

  142. 

  143. void MatrixPlugin::Execute()

  144. {	

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

  146. 	{

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

  148. 		

  149. 		// inc time 

  150. 		m_Time+=m_TickTime;

  151. 		

  152. 		SetOutputPitch(0,n,m_CurrentNoteCV);

  153. 		SetOutput(1,n,m_CurrentTriggerCV);

  154.                 

  155. 		// clear the pattern sync

  156.         SetOutput(18, n, 0);

  157. 		

  158. 		bool ExternalClock = InputExists(4);

  159. 		bool ExternalClockTriggered=false;

  160. 		 

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

  162. 		{

  163. 			if (!m_Triggered)

  164. 			{

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

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

  167. 				// No other notes catered for

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

  169. 				{

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

  171. 					{						

  172. 						m_Current=i;

  173. 						break;

  174. 					}

  175. 				}

  176. 				

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

  178. 				// will be the first one								

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

  180. 				m_Step=-1;

  181. 				ExternalClockTriggered=true;

  182. 				m_Triggered=true;

  183. 			}

  184. 		}

  185. 		else

  186. 		{

  187. 			m_Triggered=false;

  188. 		}

  189. 

  190. 

  191. 		// set the individual triggers

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

  193. 		

  194. 		if (ExternalClock)

  195. 		{

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

  197. 			{

  198. 				if(!m_ClockHigh)

  199. 				{

  200. 					m_ClockHigh=true;

  201. 					ExternalClockTriggered=true;

  202. 				}

  203. 			}

  204. 			else

  205. 			{

  206. 				if (m_ClockHigh)

  207. 				{

  208. 					m_ClockHigh=false;

  209. 					ExternalClockTriggered=true;

  210. 				}

  211. 			}

  212. 			

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

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

  215. 			{

  216. 				m_Step=-1;

  217. 				ExternalClockTriggered=true;

  218. 			}

  219. 		}

  220. /* not yet...			

  221. 		// external pattern advance

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

  223. 		{

  224. 			if (!m_PatAdvance)

  225. 			{

  226. 				m_Current++;

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

  228. 				m_PatAdvance=true;

  229. 				m_Step=-1;

  230. 				ExternalClockTriggered=true;

  231. 			}

  232. 		}

  233. 		else

  234. 		{

  235. 			m_PatAdvance=false;

  236. 		}

  237. 		

  238. 		// external pattern reset

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

  240. 		{

  241. 			if (!m_PatReset)

  242. 			{

  243. 				m_Current=0;

  244. 				m_PatReset=true;

  245. 				m_Step=-1;

  246. 				ExternalClockTriggered=true;

  247. 			}

  248. 		}

  249. 		else

  250. 		{

  251. 			m_PatReset=false;

  252. 		}	

  253. */		

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

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

  256. 			(ExternalClock && ExternalClockTriggered)) 

  257. 		{		

  258. 			m_Time=0;

  259. 			m_Step++;

  260. 			

  261. 			

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

  263. 			{

  264. 				SetOutput(18, n, 1);

  265. 				m_Step=0;

  266. 			}

  267. 						

  268. 			// Reset the values

  269. 			m_CurrentTriggerCV=0;

  270. 			if (m_NoteCut) m_CurrentNoteCV=0;

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

  272. 			{

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

  274. 				m_TriggerLevel[t]=0;

  275. 			}

  276. 			

  277. 			// Scan the matrix at current time 

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

  279. 			{

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

  281. 				{

  282. 				

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

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

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

  286. 				}

  287. 			}

  288. 			

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

  290. 			// otherwise consecutive events wont get triggered

  291. 			SetOutput(1,n,0);

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

  293. 		}

  294. 	}

  295. }

  296. 

  297. void MatrixPlugin::ExecuteCommands()

  298. {

  299. 	if (m_AudioCH->IsCommandWaiting())

  300. 	{

  301. 		switch (m_AudioCH->GetCommand())

  302. 		{

  303. 			case MAT_LENGTH   :

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

  305. 			break;

  306. 			

  307. 			case MAT_SPEED    : 

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

  309. 			break;		

  310. 			

  311. 			case MAT_ACTIVATE : 

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

  313. 			break;		

  314. 			

  315. 			case MAT_DEACTIVATE : 

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

  317. 			break;

  318. 			case MAT_OCTAVE : 

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

  320. 			break;

  321. 			case COPY : 

  322. 				CopyPattern(); 

  323. 			break;

  324. 			case PASTE : 

  325. 				PastePattern(); 

  326. 			break;

  327. 			case CLEAR : 

  328. 				ClearPattern(); 

  329. 			break;

  330. 			case TUP : 

  331. 				if (CanTransposeUp()) TransposeUp(); 

  332. 			break;

  333. 			case TDOWN : 

  334. 				if (CanTransposeDown()) TransposeDown(); 

  335. 			break;

  336. 			case MAT_VOLUME : 

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

  338. 			break;

  339. 			case SET_CURRENT : 

  340. 				m_Current=m_GUIArgs.Num; 

  341. 			break;

  342. 		}

  343. 	}

  344. }

  345. 

  346. void MatrixPlugin::PastePattern() {

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

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

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

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

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

  352.              m_Matrix[m_Current].Matrix[x][y] = m_Matrix[m_CopyPattern].Matrix[x][y];

  353.          }

  354.      }

  355. }

  356. 

  357. void MatrixPlugin::ClearPattern() {

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

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

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

  361.          }

  362.      }

  363. }

  364. 

  365. void MatrixPlugin::TransposeUp() {

  366.      int x, y;

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

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

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

  370.          }

  371.      }

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

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

  374.      }

  375. }

  376. 

  377. void MatrixPlugin::TransposeDown() 

  378. {

  379.     int x, y;

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

  381. 	{

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

  383. 		{

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

  385.         }

  386.     }

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

  388. 	{

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

  390.     }

  391. }

  392. 

  393. bool MatrixPlugin::CanTransposeDown() 

  394. {

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

  396.     return True;

  397. }

  398. 

  399. bool MatrixPlugin::CanTransposeUp() 

  400. {

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

  402.      return True;

  403. }

  404. 

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

  406. {

  407. 	s<<m_Version<<" ";

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

  409. 	

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

  411. 	{

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

  413. 		

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

  415. 		{

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

  417. 			{

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

  419. 			}

  420. 		}

  421. 		s<<"-1 ";

  422. 	}

  423. }

  424. 

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

  426. {

  427. 	int version;

  428. 	s>>version;

  429. 	

  430. 	switch (version)

  431. 	{

  432. 		case 1:

  433. 		{

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

  435. 	

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

  437. 			{	

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

  439. 		

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

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

  442. 				{

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

  444. 				}

  445. 			}

  446. 		} break;

  447. 	

  448. 		case 2:

  449. 		{

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

  451. 	

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

  453. 			{	

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

  455. 		

  456. 				int x=0,y=0;

  457. 				while(x!=-1)

  458. 				{

  459. 					s>>x;

  460. 					if (x!=-1)

  461. 					{						

  462. 						s>>y;

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

  464. 					}

  465. 				}

  466. 			}

  467. 		} break;

  468. 		

  469. 		case 3:

  470. 		{

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

  472. 	

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

  474. 			{	

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

  476. 		

  477. 				int x=0,y=0;

  478. 				float v;

  479. 				while(x!=-1)

  480. 				{

  481. 					s>>x;

  482. 					if (x!=-1)

  483. 					{						

  484. 						s>>y>>v;

  485. 						if (y!=-1) 

  486. 						{

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

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

  489. 						}

  490. 					}

  491. 				}

  492. 			}

  493. 		} break;

  494. 	}

  495. }