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

481 lines
12KB
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 "../../NoteTable.h"

  23. 

  24. using namespace std;

  25. 

  26. extern "C" {

  27. SpiralPlugin* SpiralPlugin_CreateInstance()

  28. {

  29. 	return new MatrixPlugin;

  30. }

  31. 

  32. char** SpiralPlugin_GetIcon()

  33. {

  34. 	return SpiralIcon_xpm;

  35. }

  36. 

  37. int SpiralPlugin_GetID()

  38. {

  39. 	return 0x0012;

  40. }

  41. 

  42. string SpiralPlugin_GetGroupName()

  43. {

  44. 	return "Sequencing";

  45. }

  46. }

  47. 

  48. ///////////////////////////////////////////////////////

  49. 

  50. MatrixPlugin::MatrixPlugin() :

  51. m_TickTime(1.0f),

  52. m_StepTime(1.0f),

  53. m_Time(0.0f),

  54. m_Step(0),

  55. m_Loop(true),

  56. m_NoteCut(false),

  57. m_Current(0),

  58. m_GUICurrent(0),

  59. m_CurPatSeq(0),

  60. m_CurrentNoteCV(0),

  61. m_CurrentTriggerCV(0),

  62. m_Triggered(false),

  63. m_ClockHigh(false),

  64. m_CopyPattern(0),

  65. m_PatAdvance(false),

  66. m_PatReset(false)

  67. {

  68. 	m_Version=4;

  69. 

  70. 	m_PluginInfo.Name="Matrix";

  71. 	m_PluginInfo.Width=600;

  72. 	m_PluginInfo.Height=270;

  73. 	m_PluginInfo.NumInputs=5;

  74. 	m_PluginInfo.NumOutputs=19;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  101. 		

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

  103. 	{

  104. 		m_Matrix[n].Length=64;

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

  106. 		m_Matrix[n].Octave=0;

  107. 		

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

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

  110. 		{

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

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

  113. 		}

  114. 

  115. 		m_TriggerLevel[n]=0;

  116. 	}

  117. 

  118. 	for (int n=0; n<NUM_PATSEQ; n++)

  119. 	{

  120. 		if (n ==0) m_PatSeq[n]=0; else  m_PatSeq[n]=-1;

  121. 	}

  122. 

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

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

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

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

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

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

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

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

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

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

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

  134. 	m_AudioCH->Register("PatSeqStep",&m_CurPatSeq,ChannelHandler::OUTPUT);

  135. 	m_AudioCH->Register("EchoCur", &m_Current, ChannelHandler::OUTPUT);

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

  137. }

  138. 

  139. MatrixPlugin::~MatrixPlugin()

  140. {

  141. }

  142. 

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

  144. {	

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

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

  147. 	return Info;

  148. }

  149. 

  150. SpiralGUIType *MatrixPlugin::CreateGUI()

  151. {

  152. 	return new MatrixPluginGUI(m_PluginInfo.Width,

  153. 								  	    m_PluginInfo.Height,

  154. 										this,m_AudioCH,m_HostInfo);

  155. }

  156. 

  157. void MatrixPlugin::Reset()

  158. {

  159. 	ResetPorts();

  160. 	m_Current = GetPatSeq(0);

  161. 	m_GUICurrent = 0;

  162. 	m_Time = 0.0f;

  163. 	m_Step = 0;

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

  165. 	m_StepTime = 1.0f;

  166. 	m_CurPatSeq = 0;

  167. 	m_CurrentNoteCV = 0;

  168. 	m_CurrentTriggerCV = 0;

  169. 	m_Triggered = false;

  170. 	m_ClockHigh = false;

  171. 	m_CopyPattern = 0;

  172. 	m_PatAdvance = false;

  173. 	m_PatReset = false;

  174. }

  175. 

  176. void MatrixPlugin::Execute()

  177. {	

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

  179. 	{

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

  181. 		

  182. 		// inc time 

  183. 		m_Time+=m_TickTime;

  184. 		

  185. 		SetOutputPitch(0,n,m_CurrentNoteCV);

  186. 		SetOutput(1,n,m_CurrentTriggerCV);

  187.                 

  188. 		// clear the pattern sync

  189.         SetOutput(18, n, 0);

  190. 		

  191. 		bool ExternalClock = InputExists(4);

  192. 		bool ExternalClockTriggered=false;

  193. 		 

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

  195. 		{

  196. 			if (!m_Triggered)

  197. 			{

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

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

  200. 				// No other notes catered for

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

  202. 				{

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

  204. 					{						

  205. 						m_Current=i;

  206. 						break;

  207. 					}

  208. 				}

  209. 				

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

  211. 				// will be the first one								

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

  213. 				m_Step=-1;

  214. 				ExternalClockTriggered=true;

  215. 				m_Triggered=true;

  216. 			}

  217. 		}

  218. 		else

  219. 		{

  220. 			m_Triggered=false;

  221. 		}

  222. 

  223. 

  224. 		// set the individual triggers

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

  226. 		

  227. 		if (ExternalClock)

  228. 		{

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

  230. 			{

  231. 				if(!m_ClockHigh)

  232. 				{

  233. 					m_ClockHigh=true;

  234. 					ExternalClockTriggered=true;

  235. 				}

  236. 			}

  237. 			else

  238. 			{

  239. 				if (m_ClockHigh)

  240. 				{

  241. 					m_ClockHigh=false;

  242. 					ExternalClockTriggered=true;

  243. 				}

  244. 			}

  245. 			

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

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

  248. 			{

  249. 				m_Step=-1;

  250. 				ExternalClockTriggered=true;

  251. 				m_CurPatSeq++;

  252. 				if (m_PatSeq[m_CurPatSeq]==-1 || m_CurPatSeq==NUM_PATSEQ) m_CurPatSeq=0;

  253. 				m_Current=m_PatSeq[m_CurPatSeq];

  254. 			}

  255. 		}

  256. 

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

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

  259. 			(ExternalClock && ExternalClockTriggered))

  260. 		{

  261. 			m_Time=0;

  262. 			m_Step++;

  263. 

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

  265. 			{

  266. 				SetOutput(18, n, 1);

  267. 				m_Step=0;

  268. 				m_CurPatSeq++;

  269. 				if (m_PatSeq[m_CurPatSeq]==-1 || m_CurPatSeq==NUM_PATSEQ) m_CurPatSeq=0;

  270. 				m_Current=m_PatSeq[m_CurPatSeq];

  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. 					m_CurrentNoteCV=NoteTable[i+m_Matrix[m_Current].Octave*12];

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

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

  290. 				}

  291. 			}

  292. 

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

  294. 			// otherwise consecutive events wont get triggered

  295. 			SetOutput(1,n,0);

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

  297. 		}

  298. 	}

  299. }

  300. 

  301. void MatrixPlugin::ExecuteCommands()

  302. {

  303. 	if (m_AudioCH->IsCommandWaiting())

  304. 	{

  305. 		switch (m_AudioCH->GetCommand())

  306. 		{

  307. 			case MAT_LENGTH   :

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

  309. 			break;

  310. 

  311. 			case MAT_SPEED    :

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

  313. 			break;

  314. 

  315. 			case MAT_ACTIVATE :

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

  317. 			break;

  318. 

  319. 			case MAT_DEACTIVATE :

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

  321. 			break;

  322. 			case MAT_OCTAVE :

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

  324. 			break;

  325. 			case COPY :

  326.                                 m_CopyPattern = m_GUICurrent;

  327. 			break;

  328. 			case PASTE :

  329. 				PastePattern();

  330. 			break;

  331. 			case CLEAR :

  332. 				ClearPattern();

  333. 			break;

  334. 			case TUP :

  335. 				if (CanTransposeUp()) TransposeUp();

  336. 			break;

  337. 			case TDOWN :

  338. 				if (CanTransposeDown()) TransposeDown();

  339. 			break;

  340. 			case MAT_VOLUME :

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

  342. 			break;

  343. 			case SET_CURRENT :

  344. 				m_Current=m_GUIArgs.Num;

  345. 			break;

  346. 			case SET_PATSEQ :

  347. 				m_PatSeq[m_GUIArgs.Y]=m_GUIArgs.Num;

  348. 			break;

  349. 		}

  350. 	}

  351. }

  352. 

  353. void MatrixPlugin::PastePattern() {

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

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

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

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

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

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

  360.          }

  361.      }

  362. }

  363. 

  364. void MatrixPlugin::ClearPattern() {

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

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

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

  368.          }

  369.      }

  370. }

  371. 

  372. void MatrixPlugin::TransposeUp() {

  373.      int x, y;

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

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

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

  377.          }

  378.      }

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

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

  381.      }

  382. }

  383. 

  384. void MatrixPlugin::TransposeDown()

  385. {

  386.     int x, y;

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

  388. 	{

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

  390. 		{

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

  392.         }

  393.     }

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

  395. 	{

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

  397.     }

  398. }

  399. 

  400. bool MatrixPlugin::CanTransposeDown()

  401. {

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

  403.     return true;

  404. }

  405. 

  406. bool MatrixPlugin::CanTransposeUp()

  407. {

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

  409.      return true;

  410. }

  411. 

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

  413. {

  414. 	s<<m_Version<<" ";

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

  416. 

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

  418. 	{

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

  420. 

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

  422. 		{

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

  424. 			{

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

  426. 			}

  427. 		}

  428. 		s<<"-1 ";

  429. 	}

  430. 	s<<endl;

  431. 	for (int n=0; n<NUM_PATSEQ; n++)

  432. 	{

  433. 		s<<m_PatSeq[n]<<" ";

  434. 	}

  435. 

  436. }

  437. 

  438. void MatrixPlugin::StreamIn (istream &s) {

  439.      int version;

  440.      s >> version;

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

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

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

  444.          if (version == 1) {

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

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

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

  448.          }

  449.          else {

  450.             // version > 1

  451.             float vol;

  452.             int x=0, y=0;

  453.             while (x!=-1) {

  454.                   s >> x;

  455.                   if (x != -1) {

  456.                      if (version == 2) {

  457.                         s >> y;

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

  459.                      }

  460.                      else {

  461.                         // version > 2

  462.                         s >> y >> vol;

  463.                         if (y != -1) {

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

  465.                            m_Matrix[n].Volume[x][y] = vol;

  466.                         }

  467.                      }

  468.                   }

  469.             }

  470.          }

  471.      }

  472.      if (version > 3) {

  473.         int ps;

  474.         for (int n=0; n<NUM_PATSEQ; n++) {

  475.             s >> ps;

  476.             if (n==0 && ps<0) ps = 0;

  477.             m_PatSeq[n] = ps;

  478.         }

  479.      }

  480. }