VCVRack
/
Rack
mirror of https://github.com/VCVRack/Rack.git
1
0
Fork 0
Code Issues 0 Releases 44 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.
1054 Commits
4 Branches
616MB
Tree: 37176f2064
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '37176f2064'
${ noResults }
Rack/plugins/community/repos/mscHack/src/Seq_Triad2.cpp

1158 lines
33KB
Raw Blame History 

  1. #include "mscHack.hpp"

  2. //#include "mscHack_Controls.hpp"

  3. #include "dsp/digital.hpp"

  4. //#include "CLog.h"

  5. #include "window.hpp"

  6. namespace rack_plugin_mscHack {

  7. 

  8. #define nKEYBOARDS  3

  9. #define nKEYS       37

  10. #define nOCTAVESEL  5

  11. #define nPATTERNS   16

  12. #define nPHRASE_SAVES 8

  13. #define SEMI ( 1.0f / 12.0f )

  14. 

  15. typedef struct

  16. {

  17.     float        fsemi;

  18. 

  19. }KEYBOARD_KEY_STRUCT;

  20. 

  21. typedef struct

  22. {

  23.     int     note;

  24.     bool    bTrigOff;

  25.     int     pad[ 6 ];

  26. 

  27. }PATTERN_STRUCT;

  28. 

  29. typedef struct

  30. {

  31.     bool    bPending;

  32.     int     phrase;

  33. }PHRASE_CHANGE_STRUCT;

  34. 

  35. //-----------------------------------------------------

  36. // Module Definition

  37. //

  38. //-----------------------------------------------------

  39. struct Seq_Triad2 : Module 

  40. {

  41. #define NO_COPY -1

  42. 

  43. 	enum ParamIds 

  44.     {

  45.         PARAM_PAUSE,          

  46.         PARAM_OCTAVES           = PARAM_PAUSE + ( nKEYBOARDS ),

  47.         PARAM_GLIDE             = PARAM_OCTAVES + (nOCTAVESEL * nKEYBOARDS),

  48.         PARAM_TRIGOFF           = PARAM_GLIDE + ( nKEYBOARDS ),

  49.         nPARAMS                 = PARAM_TRIGOFF + ( nKEYBOARDS )

  50.     };

  51. 

  52. 	enum InputIds 

  53.     {

  54.         IN_PATTERN_TRIG,

  55.         IN_VOCT_OFF             = IN_PATTERN_TRIG + ( nKEYBOARDS ),

  56.         IN_PROG_CHANGE          = IN_VOCT_OFF + ( nKEYBOARDS ),

  57.         IN_CLOCK_RESET          = IN_PROG_CHANGE + ( nKEYBOARDS ),

  58.         IN_GLOBAL_PAT_CLK,

  59. 		IN_GLOBAL_TRIG_MUTE,

  60. 		IN_CHANNEL_TRIG_MUTE,

  61.         nINPUTS					= IN_CHANNEL_TRIG_MUTE + ( nKEYBOARDS )

  62. 	};

  63. 

  64. 	enum OutputIds 

  65.     {

  66.         OUT_TRIG,               

  67.         OUT_VOCTS               = OUT_TRIG + nKEYBOARDS,

  68.         nOUTPUTS                = OUT_VOCTS + nKEYBOARDS

  69. 	};

  70. 

  71.     CLog            lg;

  72.     bool            m_bInitialized = false;

  73. 

  74.     // octaves

  75.     int             m_Octave[ nKEYBOARDS ] = {};

  76.     float           m_fCvStartOut[ nKEYBOARDS ] = {};

  77.     float           m_fCvEndOut[ nKEYBOARDS ] = {};

  78. 

  79.     // patterns

  80.     int             m_CurrentPattern[ nKEYBOARDS ] = {};

  81.     PATTERN_STRUCT  m_PatternNotes[ nKEYBOARDS ][ nPHRASE_SAVES ][ nPATTERNS ] = {};

  82.     SchmittTrigger  m_SchTrigPatternSelectInput[ nKEYBOARDS ];

  83.     PatternSelectStrip *m_pPatternSelect[ nKEYBOARDS ] = {};

  84. 

  85.     int             m_CopySrc = NO_COPY;

  86. 

  87.     // phrase save

  88.     int             m_CurrentPhrase[ nKEYBOARDS ] = {};

  89.     PHRASE_CHANGE_STRUCT m_PhrasePending[ nKEYBOARDS ] = {};

  90.     SchmittTrigger  m_SchTrigPhraseSelect[ nKEYBOARDS ] = {};

  91.     int             m_PhrasesUsed[ nKEYBOARDS ] = {0};

  92.     PatternSelectStrip *m_pPhraseSelect[ nKEYBOARDS ] = {};

  93. 

  94.     // number of steps

  95.     int             m_nSteps[ nKEYBOARDS ][ nPHRASE_SAVES ] = {};    

  96. 

  97.     // pause button

  98.     bool            m_bPause[ nKEYBOARDS ] = {};

  99. 

  100.     // trig mute

  101.     bool            m_bTrigMute = false;

  102.     MyLEDButton     *m_pButtonTrigMute = NULL;

  103. 

  104.     // channel trig mute

  105.     bool            m_bChTrigMute[ nKEYBOARDS ] = {};

  106.     MyLEDButton     *m_pButtonChTrigMute[ nKEYBOARDS ] = {};

  107. 

  108.     // triggers     

  109.     bool            m_bTrig[ nKEYBOARDS ] = {};

  110.     PulseGenerator  m_gatePulse[ nKEYBOARDS ];

  111. 

  112.     // global triggers

  113.     SchmittTrigger  m_SchTrigGlobalClkReset;

  114.     SchmittTrigger  m_SchTrigGlobalPatChange;

  115.     bool            m_GlobalClkResetPending = false;

  116. 

  117.     // glide

  118.     float           m_fglideInc[ nKEYBOARDS ] = {};

  119.     int             m_glideCount[ nKEYBOARDS ] = {};

  120.     float           m_fglide[ nKEYBOARDS ] = {};

  121.     float           m_fLastNotePlayed[ nKEYBOARDS ];

  122.     bool            m_bWasLastNotePlayed[ nKEYBOARDS ] = {};

  123. 

  124.     Keyboard_3Oct_Widget *pKeyboardWidget[ nKEYBOARDS ];

  125.     float           m_fKeyNotes[ 37 ];

  126. 

  127.     float           m_VoctOffsetIn[ nKEYBOARDS ] = {};

  128. 

  129.     // buttons

  130.     MyLEDButtonStrip *m_pButtonOctaveSelect[ nKEYBOARDS ] = {};

  131.     MyLEDButton      *m_pButtonPause[ nKEYBOARDS ] = {};

  132.     MyLEDButton      *m_pButtonTrig[ nKEYBOARDS ] = {};

  133.     MyLEDButton      *m_pButtonCopy[ nKEYBOARDS ] = {};

  134. 

  135. 	float flast[ nKEYBOARDS ] = {};

  136. 

  137.     // Constructor

  138. 	Seq_Triad2() : Module( nPARAMS, nINPUTS, nOUTPUTS, 0 )

  139.     {

  140.         int i;

  141. 

  142.         for( i = 0; i < 37; i++ )

  143.             m_fKeyNotes[ i ] = (float)i * SEMI;

  144.     

  145.     }

  146. 

  147.     // Overrides 

  148. 	void    step() override;

  149.     json_t* toJson() override;

  150.     void    fromJson(json_t *rootJ) override;

  151.     void    onRandomize() override;

  152.     void    onReset() override;

  153. 

  154.     void    SetPhraseSteps( int kb, int nSteps );

  155.     void    SetSteps( int kb, int steps );

  156.     void    SetKey( int kb );

  157.     void    SetOut( int kb );

  158.     void    ChangePattern( int kb, int index, bool bForce, bool bPlay );

  159.     void    ChangePhrase( int kb, int index, bool bForce );

  160.     void    SetPendingPhrase( int kb, int phrase );

  161.     void    Copy( int kb, bool bOn );

  162. };

  163. 

  164. //-----------------------------------------------------

  165. // Seq_Triad2_OctSelect

  166. //-----------------------------------------------------

  167. void Seq_Triad2_OctSelect( void *pClass, int id, int nbutton, bool bOn )

  168. {

  169.     Seq_Triad2 *mymodule;

  170.     mymodule = (Seq_Triad2*)pClass;

  171. 

  172.     mymodule->m_Octave[ id ] = nbutton;

  173.     mymodule->SetOut( id );

  174. }

  175. 

  176. //-----------------------------------------------------

  177. // Seq_Triad2_Pause

  178. //-----------------------------------------------------

  179. void Seq_Triad2_Pause( void *pClass, int id, bool bOn ) 

  180. {

  181.     Seq_Triad2 *mymodule;

  182.     mymodule = (Seq_Triad2*)pClass;

  183.     mymodule->m_bPause[ id ] = !mymodule->m_bPause[ id ];

  184. }

  185. 

  186. //-----------------------------------------------------

  187. // Seq_Triad2_TrigMute

  188. //-----------------------------------------------------

  189. void Seq_Triad2_TrigMute( void *pClass, int id, bool bOn )

  190. {

  191.     Seq_Triad2 *mymodule;

  192.     mymodule = (Seq_Triad2*)pClass;

  193.     mymodule->m_bTrigMute = bOn;

  194. }

  195. 

  196. //-----------------------------------------------------

  197. // Seq_Triad2_ChTrigMute

  198. //-----------------------------------------------------

  199. void Seq_Triad2_ChTrigMute( void *pClass, int id, bool bOn )

  200. {

  201.     Seq_Triad2 *mymodule;

  202.     mymodule = (Seq_Triad2*)pClass;

  203.     mymodule->m_bChTrigMute[ id ] = bOn;

  204. }

  205. 

  206. //-----------------------------------------------------

  207. // Seq_Triad2_Trig

  208. //-----------------------------------------------------

  209. void Seq_Triad2_Trig( void *pClass, int id, bool bOn ) 

  210. {

  211.     Seq_Triad2 *mymodule;

  212.     mymodule = (Seq_Triad2*)pClass;

  213.     mymodule->m_PatternNotes[ id ][ mymodule->m_CurrentPhrase[ id ] ][ mymodule->m_CurrentPattern[ id ] ].bTrigOff = bOn;//!mymodule->m_PatternNotes[ id ][ mymodule->m_CurrentPhrase[ id ] ][ mymodule->m_CurrentPattern[ id ] ].bTrigOff;

  214. }

  215. 

  216. //-----------------------------------------------------

  217. // Procedure:   Widget

  218. //

  219. //-----------------------------------------------------

  220. void Seq_Triad2_Widget_NoteChangeCallback ( void *pClass, int kb, int notepressed, int *pnotes, bool bOn, int button )

  221. {

  222. 	bool bCtrl = false;

  223.     Seq_Triad2 *mymodule = (Seq_Triad2 *)pClass;

  224. 

  225.     if( !pClass )

  226.         return;

  227. 

  228.     // don't allow program unless paused

  229.     if( button == 1 && !mymodule->m_bPause[ kb ] )

  230.         return;

  231. 

  232.     // right click advance step

  233.     if( button == 1 )

  234.     {

  235.     	if( windowIsModPressed() )

  236.     		bCtrl = true;

  237. 

  238.         mymodule->ChangePattern( kb, mymodule->m_CurrentPattern[ kb ] + 1, true, false );

  239. 

  240.         if( mymodule->m_CurrentPattern[ kb ] == 0 )

  241.         	mymodule->ChangePhrase( kb, mymodule->m_CurrentPhrase[ kb ] + 1, true );

  242. 

  243.         // hit control to set trig off

  244.         if( bCtrl )

  245.         	mymodule->m_PatternNotes[ kb ][ mymodule->m_CurrentPhrase[ kb ] ][ mymodule->m_CurrentPattern[ kb ] ].bTrigOff = true;

  246.         else

  247.         	mymodule->m_PatternNotes[ kb ][ mymodule->m_CurrentPhrase[ kb ] ][ mymodule->m_CurrentPattern[ kb ] ].bTrigOff = false;

  248. 

  249.         mymodule->m_pButtonTrig[ kb ]->Set( bCtrl );

  250. 

  251.         mymodule->m_PatternNotes[ kb ][ mymodule->m_CurrentPhrase[ kb ] ][ mymodule->m_CurrentPattern[ kb ] ].note = notepressed;

  252.         mymodule->SetKey( kb );

  253.     }

  254.     else

  255.         mymodule->m_PatternNotes[ kb ][ mymodule->m_CurrentPhrase[ kb ] ][ mymodule->m_CurrentPattern[ kb ] ].note = notepressed;

  256. 

  257.     mymodule->SetOut( kb );

  258. }

  259. 

  260. //-----------------------------------------------------

  261. // Procedure:   PatternChangeCallback

  262. //

  263. //-----------------------------------------------------

  264. void Seq_Triad2_Widget_PatternChangeCallback ( void *pClass, int kb, int pat, int max )

  265. {

  266.     Seq_Triad2 *mymodule = (Seq_Triad2 *)pClass;

  267. 

  268.     if( !mymodule || !mymodule->m_bInitialized )

  269.         return;

  270. 

  271.     if( mymodule->m_CurrentPattern[ kb ] != pat )

  272.         mymodule->ChangePattern( kb, pat, false, true );

  273.     else if( mymodule->m_nSteps[ kb ][ mymodule->m_CurrentPhrase[ kb ] ] != max )

  274.         mymodule->SetSteps( kb, max );

  275. }

  276. 

  277. //-----------------------------------------------------

  278. // Procedure:   PhraseChangeCallback

  279. //

  280. //-----------------------------------------------------

  281. void Seq_Triad2_Widget_PhraseChangeCallback ( void *pClass, int kb, int pat, int max )

  282. {

  283.     Seq_Triad2 *mymodule = (Seq_Triad2 *)pClass;

  284. 

  285.     if( !mymodule || !mymodule->m_bInitialized )

  286.         return;

  287. 

  288.     if( mymodule->m_PhrasesUsed[ kb ] != max )

  289.     {

  290.         mymodule->SetPhraseSteps( kb, max ); 

  291.     }

  292.     else if( mymodule->m_CurrentPhrase[ kb ] == pat && mymodule->m_bPause[ kb ] && mymodule->m_CopySrc != NO_COPY )

  293.     {

  294.         mymodule->ChangePhrase( kb, pat, true );

  295.     }

  296.     else if( mymodule->m_CurrentPhrase[ kb ] != pat )

  297.     {

  298.         if( !mymodule->m_bPause[ kb ] && mymodule->inputs[ Seq_Triad2::IN_PATTERN_TRIG + kb ].active )

  299.             mymodule->SetPendingPhrase( kb, pat );

  300.         else

  301.             mymodule->ChangePhrase( kb, pat, false );

  302.             

  303.     }

  304. }

  305. 

  306. //-----------------------------------------------------

  307. // MyLEDButton_Copy

  308. //-----------------------------------------------------

  309. void MyLEDButton_Copy( void *pClass, int id, bool bOn ) 

  310. {

  311.     Seq_Triad2 *mymodule;

  312.     mymodule = (Seq_Triad2*)pClass;

  313.     mymodule->Copy( id, bOn );

  314. }

  315. 

  316. //-----------------------------------------------------

  317. // Procedure:   Widget

  318. //

  319. //-----------------------------------------------------

  320. 

  321. struct Seq_Triad2_Widget : ModuleWidget {

  322. 	Seq_Triad2_Widget( Seq_Triad2 *module );

  323. };

  324. 

  325. Seq_Triad2_Widget::Seq_Triad2_Widget( Seq_Triad2 *module ) : ModuleWidget(module) 

  326. {

  327.     int kb, x, x2, y, y2;

  328. 

  329. 	box.size = Vec( 15*25, 380);

  330. 

  331. 	{

  332. 		SVGPanel *panel = new SVGPanel();

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

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

  335. 		addChild(panel);

  336. 	}

  337. 

  338.     //module->lg.Open("TriadSequencer2.txt");

  339. 

  340.     //----------------------------------------------------

  341.     // Keyboard Keys 

  342.     y = 21;

  343.     x = 11;

  344. 

  345.     for( kb = 0; kb < nKEYBOARDS; kb++ )

  346.     {

  347.         // channel trig mute

  348.         module->m_pButtonChTrigMute[ kb ] = new MyLEDButton( x + 310, y + 3, 15, 15, 13.0, DWRGB( 180, 180, 180 ), DWRGB( 255, 0, 0 ), MyLEDButton::TYPE_SWITCH, kb, module, Seq_Triad2_ChTrigMute );

  349.         addChild( module->m_pButtonChTrigMute[ kb ] );

  350. 

  351.         addInput(Port::create<MyPortInSmall>( Vec( x + 285, y + 1 ), Port::INPUT, module, Seq_Triad2::IN_CHANNEL_TRIG_MUTE + kb ) );

  352. 

  353.         // pause button

  354.         module->m_pButtonPause[ kb ] = new MyLEDButton( x + 60, y + 4, 11, 11, 8.0, DWRGB( 180, 180, 180 ), DWRGB( 255, 0, 0 ), MyLEDButton::TYPE_SWITCH, kb, module, Seq_Triad2_Pause );

  355. 	    addChild( module->m_pButtonPause[ kb ] );

  356. 

  357.         // trig button

  358.         module->m_pButtonTrig[ kb ] = new MyLEDButton( x + 260, y + 5, 11, 11, 8.0, DWRGB( 180, 180, 180 ), DWRGB( 255, 0, 0 ), MyLEDButton::TYPE_SWITCH, kb, module, Seq_Triad2_Trig );

  359. 	    addChild( module->m_pButtonTrig[ kb ] );

  360. 

  361.         // glide knob

  362.         addParam( ParamWidget::create<Knob_Yellow1_15>( Vec( x + 235, y + 86 ), module, Seq_Triad2::PARAM_GLIDE + kb, 0.0, 1.0, 0.0 ) );

  363. 

  364.         module->m_pButtonCopy[ kb ] = new MyLEDButton( x + 194, y + 89, 11, 11, 8.0, DWRGB( 180, 180, 180 ), DWRGB( 0, 244, 244 ), MyLEDButton::TYPE_SWITCH, kb, module, MyLEDButton_Copy );

  365. 	    addChild( module->m_pButtonCopy[ kb ] );

  366. 

  367.         x2 = x + 274;

  368. 

  369.         // octave select

  370.         module->m_pButtonOctaveSelect[ kb ] = new MyLEDButtonStrip( x2, y + 90, 11, 11, 3, 8.0, nOCTAVESEL, false, DWRGB( 180, 180, 180 ), DWRGB( 0, 255, 255 ), MyLEDButtonStrip::TYPE_EXCLUSIVE, kb, module, Seq_Triad2_OctSelect );

  371. 	    addChild( module->m_pButtonOctaveSelect[ kb ] );

  372. 

  373.         // keyboard widget

  374.         module->pKeyboardWidget[ kb ] = new Keyboard_3Oct_Widget( x + 39, y + 19, 1, kb, DWRGB( 255, 128, 64 ), module, Seq_Triad2_Widget_NoteChangeCallback, &module->lg );

  375. 	    addChild( module->pKeyboardWidget[ kb ] );

  376. 

  377.         // pattern selects

  378.         module->m_pPatternSelect[ kb ] = new PatternSelectStrip( x + 79, y + 1, 9, 7, DWRGB( 255, 128, 64 ), DWRGB( 128, 64, 0 ), DWRGB( 255, 0, 128 ), DWRGB( 128, 0, 64 ), nPATTERNS, kb, module, Seq_Triad2_Widget_PatternChangeCallback );

  379. 	    addChild( module->m_pPatternSelect[ kb ] );

  380. 

  381.         // phrase selects

  382.         module->m_pPhraseSelect[ kb ] = new PatternSelectStrip( x + 79, y + 86, 9, 7, DWRGB( 255, 255, 0 ), DWRGB( 128, 128, 64 ), DWRGB( 0, 255, 255 ), DWRGB( 0, 128, 128 ), nPHRASE_SAVES, kb, module, Seq_Triad2_Widget_PhraseChangeCallback );

  383. 	    addChild( module->m_pPhraseSelect[ kb ] );

  384. 

  385.         x2 = x + 9;

  386.         y2 = y + 4;

  387.         // prog change trigger

  388.         addInput(Port::create<MyPortInSmall>( Vec( x2, y2 ), Port::INPUT, module, Seq_Triad2::IN_PATTERN_TRIG + kb ) ); y2 += 40;

  389. 

  390.         // VOCT offset input

  391.         addInput(Port::create<MyPortInSmall>( Vec( x2, y2 ), Port::INPUT, module, Seq_Triad2::IN_VOCT_OFF + kb ) ); y2 += 40;

  392. 

  393.         // prog change trigger

  394.         addInput(Port::create<MyPortInSmall>( Vec( x2, y2 ), Port::INPUT, module, Seq_Triad2::IN_PROG_CHANGE + kb ) );

  395. 

  396.         // outputs

  397.         x2 = x + 330;

  398.         addOutput(Port::create<MyPortOutSmall>( Vec( x2, y + 27 ), Port::OUTPUT, module, Seq_Triad2::OUT_VOCTS + kb ) );

  399.         addOutput(Port::create<MyPortOutSmall>( Vec( x2, y + 68 ), Port::OUTPUT, module, Seq_Triad2::OUT_TRIG + kb ) );

  400. 

  401.         y += 111;

  402.     }

  403. 

  404.     // trig mute

  405.     module->m_pButtonTrigMute = new MyLEDButton( x + 310, 3, 15, 15, 13.0, DWRGB( 180, 180, 180 ), DWRGB( 255, 0, 0 ), MyLEDButton::TYPE_SWITCH, 0, module, Seq_Triad2_TrigMute );

  406.     addChild( module->m_pButtonTrigMute );

  407. 

  408.     addInput(Port::create<MyPortInSmall>( Vec( x + 285, 1 ), Port::INPUT, module, Seq_Triad2::IN_GLOBAL_TRIG_MUTE ) );

  409. 

  410.     // reset inputs

  411.     y2 = 357; 

  412.     addInput(Port::create<MyPortInSmall>( Vec( x + 89, y2 ), Port::INPUT, module, Seq_Triad2::IN_CLOCK_RESET ) );

  413.     addInput(Port::create<MyPortInSmall>( Vec( x + 166, y2 ), Port::INPUT, module, Seq_Triad2::IN_GLOBAL_PAT_CLK ) );

  414. 

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

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

  417. 	addChild(Widget::create<ScrewSilver>(Vec(15, 365))); 

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

  419. 

  420.     module->m_bInitialized = true;

  421. 

  422.     module->onReset();

  423. }

  424. 

  425. //-----------------------------------------------------

  426. // Procedure:   reset

  427. //

  428. //-----------------------------------------------------

  429. void Seq_Triad2::onReset()

  430. {

  431.     if( !m_bInitialized )

  432.         return;

  433. 

  434.     for( int kb = 0; kb < nKEYBOARDS; kb++ )

  435.         m_pButtonOctaveSelect[ kb ]->Set( 0, true );

  436. 

  437.     memset( m_fCvStartOut, 0, sizeof(m_fCvStartOut) );

  438.     memset( m_fCvEndOut, 0, sizeof(m_fCvEndOut) );

  439.     memset( m_PatternNotes, 0, sizeof(m_PatternNotes) );

  440.     

  441.     for( int kb = 0; kb < nKEYBOARDS; kb++ )

  442.     {

  443.         for( int pat = 0; pat < nPHRASE_SAVES; pat++ )

  444.             m_nSteps[ kb ][ pat ] = 3;

  445. 

  446.         SetPhraseSteps( kb, 3 );

  447.         ChangePattern( kb, 0, true, true );

  448.         ChangePhrase( kb, 0, true );

  449.     }

  450. }

  451. 

  452. //-----------------------------------------------------

  453. // Procedure:   randomize

  454. //

  455. //-----------------------------------------------------

  456. const int keyscalenotes[ 7 ] = { 0, 2, 4, 5, 7, 9, 11};

  457. const int keyscalenotes_minor[ 7 ] = { 0, 2, 3, 5, 7, 9, 11};

  458. void Seq_Triad2::onRandomize()

  459. {

  460.     int kb, pat, phrase, basekey, note;

  461. 

  462.     for( int kb = 0; kb < nKEYBOARDS; kb++ )

  463.         m_pButtonOctaveSelect[ kb ]->Set( 0, true );

  464. 

  465.     memset( m_fCvStartOut, 0, sizeof(m_fCvStartOut) );

  466.     memset( m_fCvEndOut, 0, sizeof(m_fCvEndOut) );

  467.     memset( m_PatternNotes, 0, sizeof(m_PatternNotes) );

  468. 

  469.     basekey = (int)(randomUniform() * 24.0);

  470. 

  471.     for( kb = 0; kb < nKEYBOARDS; kb++ )

  472.     {

  473.         m_Octave[ kb ] = (int)( randomUniform() * 4.0 );

  474. 

  475.         for( pat = 0; pat < nPATTERNS; pat++ )

  476.         {

  477.             for( phrase = 0; phrase < nPHRASE_SAVES; phrase++ )

  478.             {

  479.                 if( randomUniform() > 0.7 )

  480.                     note = keyscalenotes_minor[ (int)(randomUniform() * 7.0 ) ];

  481.                 else

  482.                     note = keyscalenotes[ (int)(randomUniform() * 7.0 ) ];

  483. 

  484.                 m_PatternNotes[ kb ][ phrase ][ pat ].bTrigOff = ( randomUniform() < 0.10 );

  485.                 m_PatternNotes[ kb ][ phrase ][ pat ].note = basekey + note; 

  486.             }

  487.         }

  488. 

  489.         ChangePattern( kb, 0, true, true );

  490.     }

  491. }

  492. 

  493. //-----------------------------------------------------

  494. // Procedure:   SetPhraseSteps

  495. //

  496. //-----------------------------------------------------

  497. void Seq_Triad2::SetPhraseSteps( int kb, int nSteps )

  498. {

  499.     if( nSteps < 0 || nSteps >= nPHRASE_SAVES )

  500.         nSteps = 0;

  501. 

  502.     m_PhrasesUsed[ kb ] = nSteps;

  503. }

  504. 

  505. //-----------------------------------------------------

  506. // Procedure:   SetSteps

  507. //

  508. //-----------------------------------------------------

  509. void Seq_Triad2::SetSteps( int kb, int nSteps )

  510. {

  511.     if( nSteps < 0 || nSteps >= nPATTERNS )

  512.         nSteps = 0;

  513. 

  514.     m_nSteps[ kb ][ m_CurrentPhrase[ kb ] ] = nSteps;

  515. }

  516. 

  517. //-----------------------------------------------------

  518. // Procedure:   Copy

  519. //

  520. //-----------------------------------------------------

  521. void Seq_Triad2::Copy( int kb, bool bOn )

  522. {

  523.     if( kb < 0 || kb >= nKEYBOARDS )

  524.         return;

  525. 

  526.     if( !m_bPause[ kb ] || !bOn || m_CopySrc != NO_COPY )

  527.     {

  528.         if( m_CopySrc != NO_COPY )

  529.             m_pButtonCopy[ m_CopySrc ]->Set( false );

  530. 

  531.         m_CopySrc = NO_COPY;

  532.         m_pButtonCopy[ kb ]->Set( false );

  533.     }

  534.     else if( bOn )

  535.     {

  536.         m_CopySrc = kb;

  537.     }

  538. }

  539. 

  540. //-----------------------------------------------------

  541. // Procedure:   SetOut

  542. //

  543. //-----------------------------------------------------

  544. void Seq_Triad2::SetOut( int kb )

  545. {

  546.     int note;

  547.     float foct;

  548. 

  549.     if( kb < 0 || kb >= nKEYBOARDS )

  550.         return;

  551. 

  552.     // end glide note (current pattern note)

  553.     foct = (float)m_Octave[ kb ];

  554. 

  555.     note = m_PatternNotes[ kb ][ m_CurrentPhrase[ kb ] ][ m_CurrentPattern[ kb ] ].note;

  556. 

  557.     if( note > 36 || note < 0 )

  558.         note = 0;

  559. 

  560.     m_fCvEndOut[ kb ] = foct + m_fKeyNotes[ note ] + m_VoctOffsetIn[ kb ];

  561. 

  562.     // start glide note (last pattern note)

  563.     if( m_bWasLastNotePlayed[ kb ] )

  564.     {

  565.         m_fCvStartOut[ kb ] = m_fLastNotePlayed[ kb ] + m_VoctOffsetIn[ kb ];

  566.     }

  567.     else

  568.     {

  569.         m_bWasLastNotePlayed[ kb ] = true;

  570.         m_fCvStartOut[ kb ] = m_fCvEndOut[ kb ] + m_VoctOffsetIn[ kb ];

  571.     }

  572. 

  573.     m_fLastNotePlayed[ kb ] = m_fCvEndOut[ kb ] + m_VoctOffsetIn[ kb ];

  574. 

  575.     // glide time ( max glide = 0.5 seconds )

  576.     m_glideCount[ kb ] = 1 + (int)( ( params[ PARAM_GLIDE + kb ].value * 0.5 ) * engineGetSampleRate());

  577. 

  578.     m_fglideInc[ kb ] = 1.0 / (float)m_glideCount[ kb ];

  579. 

  580.     m_fglide[ kb ] = 1.0;

  581. 

  582.     // always trig on pause

  583.     if( m_bPause[ kb ] )

  584.         m_bTrig[ kb ] = true;

  585.     else if( !m_PatternNotes[ kb ][ m_CurrentPhrase[ kb ] ][ m_CurrentPattern[ kb ] ].bTrigOff )

  586.         m_bTrig[ kb ] = true;

  587.     else

  588.         m_bTrig[ kb ] = false;

  589. }

  590. 

  591. //-----------------------------------------------------

  592. // Procedure:   SetKey

  593. //

  594. //-----------------------------------------------------

  595. void Seq_Triad2::SetKey( int kb )

  596. {

  597.     pKeyboardWidget[ kb ]->setkey( &m_PatternNotes[ kb ][ m_CurrentPhrase[ kb ] ][ m_CurrentPattern[ kb ] ].note );

  598. }

  599. 

  600. //-----------------------------------------------------

  601. // Procedure:   SetPendingPhrase

  602. //

  603. //-----------------------------------------------------

  604. void Seq_Triad2::SetPendingPhrase( int kb, int phraseIn )

  605. {

  606.     int phrase;

  607. 

  608.     if( phraseIn < 0 || phraseIn >= nPHRASE_SAVES )

  609.         phrase = ( m_CurrentPhrase[ kb ] + 1 ) & 0x7;

  610.     else

  611.         phrase = phraseIn;

  612. 

  613.     if( phrase > m_PhrasesUsed[ kb ] )

  614.         phrase = 0;

  615. 

  616.     m_PhrasePending[ kb ].bPending = true;

  617.     m_PhrasePending[ kb ].phrase = phrase;

  618.     m_pPhraseSelect[ kb ]->SetPat( m_CurrentPhrase[ kb ], false );

  619.     m_pPhraseSelect[ kb ]->SetPat( phrase, true );

  620. }

  621. 

  622. //-----------------------------------------------------

  623. // Procedure:   ChangePhrase

  624. //

  625. //-----------------------------------------------------

  626. void Seq_Triad2::ChangePhrase( int kb, int index, bool bForce )

  627. {

  628.     if( kb < 0 || kb >= nKEYBOARDS )

  629.         return;

  630. 

  631.     if( !bForce && index == m_CurrentPhrase[ kb ] )

  632.         return;

  633. 

  634.     if( index < 0 )

  635.         index = nPHRASE_SAVES - 1;

  636.     else if( index >= nPHRASE_SAVES )

  637.         index = 0;

  638. 

  639.     if( m_CopySrc != NO_COPY )

  640.     {

  641.         // do not copy if we are not paused

  642.         if( m_bPause[ kb ] )

  643.         {

  644.             memcpy( m_PatternNotes[ kb ][ index ], m_PatternNotes[ m_CopySrc ][ m_CurrentPhrase[ m_CopySrc ] ], sizeof(PATTERN_STRUCT) * nPATTERNS );

  645.             m_pButtonCopy[ m_CopySrc ]->Set( false );

  646.             m_nSteps[ kb ][ index ] = m_nSteps[ m_CopySrc ][ m_CurrentPhrase[ m_CopySrc ] ];

  647.             m_CopySrc = NO_COPY;

  648.         }

  649.     }

  650. 

  651.     m_CurrentPhrase[ kb ] = index;

  652. 

  653.     m_pPhraseSelect[ kb ]->SetPat( index, false );

  654.     m_pPhraseSelect[ kb ]->SetMax( m_PhrasesUsed[ kb ] );

  655.     m_pPatternSelect[ kb ]->SetMax( m_nSteps[ kb ][ index ] );

  656. 

  657.     // set keyboard key

  658.     SetKey( kb );

  659. 

  660.     m_pButtonTrig[ kb ]->Set( m_PatternNotes[ kb ][ m_CurrentPhrase[ kb ] ][ m_CurrentPattern[ kb ] ].bTrigOff );

  661. 

  662.     // change octave light

  663.     m_pButtonOctaveSelect[ kb ]->Set( m_Octave[ kb ], true );

  664. 

  665.     // set output note

  666.     SetOut( kb );

  667. }

  668. 

  669. //-----------------------------------------------------

  670. // Procedure:   ChangePattern

  671. //

  672. //-----------------------------------------------------

  673. void Seq_Triad2::ChangePattern( int kb, int index, bool bForce, bool bPlay )

  674. {

  675.     if( kb < 0 || kb >= nKEYBOARDS )

  676.         return;

  677. 

  678.     if( !bForce && index == m_CurrentPattern[ kb ] )

  679.         return;

  680. 

  681.     if( index < 0 )

  682.         index = nPATTERNS - 1;

  683.     else if( index >= nPATTERNS )

  684.         index = 0;

  685. 

  686.     // update octave offset immediately when not running

  687.     m_VoctOffsetIn[ kb ] = inputs[ IN_VOCT_OFF + kb ].normalize( 0.0 );

  688. 

  689.     m_CurrentPattern[ kb ] = index;

  690. 

  691.     m_pPatternSelect[ kb ]->SetPat( index, false );

  692. 

  693.     // set keyboard key

  694.     SetKey( kb );

  695. 

  696.     m_pButtonTrig[ kb ]->Set( m_PatternNotes[ kb ][ m_CurrentPhrase[ kb ] ][ m_CurrentPattern[ kb ] ].bTrigOff );

  697. 

  698.     // change octave light

  699.     m_pButtonOctaveSelect[ kb ]->Set( m_Octave[ kb ], true );

  700. 

  701.     // set outputted note

  702.     if( bPlay )

  703.         SetOut( kb );

  704. }

  705. 

  706. //-----------------------------------------------------

  707. // Procedure:   

  708. //

  709. //-----------------------------------------------------

  710. json_t *Seq_Triad2::toJson() 

  711. {

  712.     int *pint;

  713.     bool *pbool;

  714.     json_t *gatesJ;

  715. 	json_t *rootJ = json_object();

  716. 

  717.     // pauses

  718.     pbool = &m_bPause[ 0 ];

  719. 

  720. 	gatesJ = json_array();

  721. 

  722. 	for (int i = 0; i < nKEYBOARDS; i++)

  723.     {

  724. 		json_t *gateJ = json_integer( (int)pbool[ i ] );

  725. 		json_array_append_new( gatesJ, gateJ );

  726. 	}

  727. 

  728. 	json_object_set_new( rootJ, "m_bPause", gatesJ );

  729. 

  730.     // number of steps

  731.     pint = (int*)&m_nSteps[ 0 ][ 0 ];

  732. 

  733. 	gatesJ = json_array();

  734. 

  735. 	for (int i = 0; i < nKEYBOARDS * nPHRASE_SAVES; i++)

  736.     {

  737. 		json_t *gateJ = json_integer( pint[ i ] );

  738. 		json_array_append_new( gatesJ, gateJ );

  739. 	}

  740. 

  741. 	json_object_set_new( rootJ, "m_nSteps", gatesJ );

  742. 

  743.     // octaves

  744.     pint = (int*)&m_Octave[ 0 ];

  745. 

  746. 	gatesJ = json_array();

  747. 

  748. 	for (int i = 0; i < nKEYBOARDS; i++)

  749.     {

  750. 		json_t *gateJ = json_integer( pint[ i ] );

  751. 		json_array_append_new( gatesJ, gateJ );

  752. 	}

  753. 

  754. 	json_object_set_new( rootJ, "m_Octave", gatesJ );

  755. 

  756.     // phrase select

  757.     pint = (int*)&m_CurrentPhrase[ 0 ];

  758. 

  759. 	gatesJ = json_array();

  760. 

  761. 	for (int i = 0; i < nKEYBOARDS; i++)

  762.     {

  763. 		json_t *gateJ = json_integer( pint[ i ] );

  764. 		json_array_append_new( gatesJ, gateJ );

  765. 	}

  766. 

  767. 	json_object_set_new( rootJ, "m_CurrentPhrase", gatesJ );

  768. 

  769.     // patterns

  770.     pint = (int*)&m_PatternNotes[ 0 ][ 0 ][ 0 ];

  771. 

  772. 	gatesJ = json_array();

  773. 

  774. 	for (int i = 0; i < (nPHRASE_SAVES * nPATTERNS * nKEYBOARDS * 8); i++)

  775.     {

  776. 		json_t *gateJ = json_integer( pint[ i ] );

  777. 		json_array_append_new( gatesJ, gateJ );

  778. 	}

  779. 

  780. 	json_object_set_new( rootJ, "m_PatternNotes", gatesJ );

  781. 

  782. 

  783.     // phrase used

  784.     pint = (int*)&m_PhrasesUsed[ 0 ];

  785. 

  786. 	gatesJ = json_array();

  787. 

  788. 	for (int i = 0; i < nKEYBOARDS; i++)

  789.     {

  790. 		json_t *gateJ = json_integer( pint[ i ] );

  791. 		json_array_append_new( gatesJ, gateJ );

  792. 	}

  793. 

  794. 	json_object_set_new( rootJ, "m_PhrasesUsed", gatesJ );

  795. 

  796.     // current pattern

  797.     pint = (int*)&m_CurrentPattern[ 0 ];

  798. 

  799. 	gatesJ = json_array();

  800. 

  801. 	for (int i = 0; i < nKEYBOARDS; i++)

  802.     {

  803. 		json_t *gateJ = json_integer( pint[ i ] );

  804. 		json_array_append_new( gatesJ, gateJ );

  805. 	}

  806. 

  807. 	json_object_set_new( rootJ, "m_CurrentPattern", gatesJ );

  808. 

  809.     // trig mute

  810. 	gatesJ = json_array();

  811. 

  812. 	json_t *gateJ = json_boolean( m_bTrigMute );

  813. 	json_array_append_new( gatesJ, gateJ );

  814. 	json_object_set_new( rootJ, "m_bTrigMute", gatesJ );

  815. 

  816.     // channel trig mute

  817.     pbool = &m_bChTrigMute[ 0 ];

  818. 

  819. 	gatesJ = json_array();

  820. 

  821. 	for (int i = 0; i < nKEYBOARDS; i++)

  822.     {

  823. 		json_t *gateJ = json_integer( pbool[ i ] );

  824. 		json_array_append_new( gatesJ, gateJ );

  825. 	}

  826. 

  827. 	json_object_set_new( rootJ, "m_bChTrigMute", gatesJ );

  828. 

  829. 	return rootJ;

  830. }

  831. 

  832. //-----------------------------------------------------

  833. // Procedure:   fromJson

  834. //

  835. //-----------------------------------------------------

  836. void Seq_Triad2::fromJson(json_t *rootJ) 

  837. {

  838.     bool *pbool;

  839.     int *pint;

  840.     int i;

  841.     json_t *StepsJ;

  842. 

  843.     // pauses

  844.     pbool = &m_bPause[ 0 ];

  845. 	StepsJ = json_object_get( rootJ, "m_bPause" );

  846. 

  847. 	if (StepsJ) 

  848.     {

  849. 		for ( i = 0; i < nKEYBOARDS; i++)

  850.         {

  851. 			json_t *gateJ = json_array_get(StepsJ, i);

  852. 

  853. 			if (gateJ)

  854. 				pbool[ i ] = json_integer_value( gateJ );

  855. 		}

  856. 	}

  857. 

  858.     // number of steps

  859.     pint = (int*)&m_nSteps[ 0 ][ 0 ];

  860. 	StepsJ = json_object_get( rootJ, "m_nSteps" );

  861. 

  862. 	if (StepsJ) 

  863.     {

  864. 		for ( i = 0; i < nKEYBOARDS * nPHRASE_SAVES; i++)

  865.         {

  866. 			json_t *gateJ = json_array_get(StepsJ, i);

  867. 

  868. 			if (gateJ)

  869. 				pint[ i ] = json_integer_value( gateJ );

  870. 		}

  871. 	}

  872. 

  873.     // octaves

  874.     pint = (int*)&m_Octave[ 0 ];

  875. 	StepsJ = json_object_get( rootJ, "m_Octave" );

  876. 

  877. 	if (StepsJ) 

  878.     {

  879. 		for ( i = 0; i < nKEYBOARDS; i++)

  880.         {

  881. 			json_t *gateJ = json_array_get(StepsJ, i);

  882. 

  883. 			if (gateJ)

  884. 				pint[ i ] = json_integer_value( gateJ );

  885. 		}

  886. 	}

  887. 

  888.     // phrase select

  889.     pint = (int*)&m_CurrentPhrase[ 0 ];

  890. 	StepsJ = json_object_get( rootJ, "m_CurrentPhrase" );

  891. 

  892. 	if (StepsJ) 

  893.     {

  894. 		for ( i = 0; i < nKEYBOARDS; i++)

  895.         {

  896. 			json_t *gateJ = json_array_get(StepsJ, i);

  897. 

  898. 			if (gateJ)

  899. 				pint[ i ] = json_integer_value( gateJ );

  900. 		}

  901. 	}

  902.     

  903.     // all patterns and phrases

  904.     pint = (int*)&m_PatternNotes[ 0 ][ 0 ][ 0 ];

  905. 

  906. 	StepsJ = json_object_get( rootJ, "m_PatternNotes" );

  907. 

  908. 	if (StepsJ) 

  909.     {

  910. 		for ( i = 0; i < (nPHRASE_SAVES * nPATTERNS * nKEYBOARDS * 8); i++)

  911.         {

  912. 			json_t *gateJ = json_array_get(StepsJ, i);

  913. 

  914. 			if (gateJ)

  915. 				pint[ i ] = json_integer_value( gateJ );

  916. 		}

  917. 	}

  918. 

  919.     // phrase steps

  920.     pint = (int*)&m_PhrasesUsed[ 0 ];

  921. 

  922. 	StepsJ = json_object_get( rootJ, "m_PhrasesUsed" );

  923. 

  924. 	if (StepsJ) 

  925.     {

  926. 		for ( i = 0; i < nKEYBOARDS; i++)

  927.         {

  928. 			json_t *gateJ = json_array_get(StepsJ, i);

  929. 

  930. 			if (gateJ)

  931. 				pint[ i ] = json_integer_value( gateJ );

  932. 		}

  933. 	}

  934. 

  935.     // current pattern

  936.     pint = (int*)&m_CurrentPattern[ 0 ];

  937. 

  938. 	StepsJ = json_object_get( rootJ, "m_CurrentPattern" );

  939. 

  940. 	if (StepsJ) 

  941.     {

  942. 		for ( i = 0; i < nKEYBOARDS; i++)

  943.         {

  944. 			json_t *gateJ = json_array_get(StepsJ, i);

  945. 

  946. 			if (gateJ)

  947. 				pint[ i ] = json_integer_value( gateJ );

  948. 		}

  949. 	}

  950. 

  951.     for( i = 0; i < nKEYBOARDS; i++ )

  952.     {

  953.         m_pPhraseSelect[ i ]->SetMax( m_PhrasesUsed[ i ] );

  954.         m_pPhraseSelect[ i ]->SetPat( m_CurrentPhrase[ i ], false );

  955. 

  956.         m_pPatternSelect[ i ]->SetMax( m_nSteps[ i ][ m_CurrentPhrase[ i ] ] );

  957.         m_pPatternSelect[ i ]->SetPat( m_CurrentPattern[ i ], false );

  958. 

  959.         m_pButtonPause[ i ]->Set( m_bPause[ i ] );

  960. 

  961.         SetPhraseSteps( i, m_PhrasesUsed[ i ] );

  962.         ChangePhrase( i, m_CurrentPhrase[ i ], true );

  963.         ChangePattern( i, m_CurrentPattern[ i ], true, false );

  964.     }

  965. 

  966.     // pauses

  967. 	StepsJ = json_object_get( rootJ, "m_bTrigMute" );

  968. 

  969. 	if (StepsJ)

  970.     {

  971. 		json_t *gateJ = json_array_get( StepsJ, 0 );

  972. 

  973. 		if (gateJ)

  974. 			m_bTrigMute = json_boolean_value( gateJ );

  975. 	}

  976. 

  977. 	if( m_bTrigMute )

  978. 		m_pButtonTrigMute->Set( m_bTrigMute );

  979. 

  980.     // channel trig mute

  981.     pbool = &m_bChTrigMute[ 0 ];

  982. 	StepsJ = json_object_get( rootJ, "m_bChTrigMute" );

  983. 

  984. 	if (StepsJ)

  985.     {

  986. 		for ( i = 0; i < nKEYBOARDS; i++)

  987.         {

  988. 			json_t *gateJ = json_array_get(StepsJ, i);

  989. 

  990. 			if (gateJ)

  991. 				pbool[ i ] = json_integer_value( gateJ );

  992. 		}

  993. 	}

  994. 

  995. 	for( i = 0; i < nKEYBOARDS; i++ )

  996. 	{

  997. 		if( m_bChTrigMute[ i ] )

  998. 			m_pButtonChTrigMute[ i ]->Set( m_bChTrigMute[ i ] );

  999. 	}

  1000. }

  1001. 

  1002. //-----------------------------------------------------

  1003. // Procedure:   step

  1004. //

  1005. //-----------------------------------------------------

  1006. #define LIGHT_LAMBDA ( 0.065f )

  1007. void Seq_Triad2::step() 

  1008. {

  1009.     int kb, useclock;

  1010.     bool bGlobalPatChange = false, bGlobalClkTriggered = false, PatTrig[ nKEYBOARDS ] = {};

  1011.     float trigout = 0.0f;

  1012. 

  1013.     if( !m_bInitialized )

  1014.         return;

  1015. 

  1016.     if( inputs[ IN_GLOBAL_TRIG_MUTE ].active )

  1017.     {

  1018. 		if( inputs[ IN_GLOBAL_TRIG_MUTE ].value >= 0.00001 )

  1019. 		{

  1020. 			m_bTrigMute = true;

  1021. 			m_pButtonTrigMute->Set( true );

  1022. 		}

  1023. 		else if( inputs[ IN_GLOBAL_TRIG_MUTE ].value < 0.00001 )

  1024. 		{

  1025. 			m_bTrigMute = false;

  1026. 			m_pButtonTrigMute->Set( false );

  1027. 		}

  1028.     }

  1029. 

  1030.     // global phrase change trigger

  1031.     if( inputs[ IN_GLOBAL_PAT_CLK ].active )

  1032.     {

  1033. 	    if( m_SchTrigGlobalPatChange.process( inputs[ IN_GLOBAL_PAT_CLK ].value ) )

  1034.             bGlobalPatChange = true;

  1035.     }

  1036. 

  1037.     // global clock reset

  1038.     if( inputs[ IN_CLOCK_RESET ].active )

  1039.     {

  1040. 	    if( m_SchTrigGlobalClkReset.process( inputs[ IN_CLOCK_RESET ].value ) )

  1041.             m_GlobalClkResetPending = true;

  1042.     }

  1043. 

  1044.     // get trigs

  1045.     for( kb = 0; kb < nKEYBOARDS; kb++ )

  1046.         PatTrig[ kb ] = m_SchTrigPatternSelectInput[ kb ].process( inputs[ IN_PATTERN_TRIG + kb ].value );

  1047. 

  1048.     // process triggered phrase changes

  1049.     for( kb = 0; kb < nKEYBOARDS; kb++ )

  1050.     {

  1051.         useclock = kb;

  1052. 

  1053.         if( inputs[ IN_CHANNEL_TRIG_MUTE + kb ].active )

  1054.         {

  1055.     		if( inputs[ IN_CHANNEL_TRIG_MUTE + kb ].value >= 0.00001 )

  1056.     		{

  1057.     			m_bChTrigMute[ kb ] = true;

  1058.     			m_pButtonChTrigMute[ kb ]->Set( true );

  1059.     		}

  1060.     		else if( inputs[ IN_CHANNEL_TRIG_MUTE + kb ].value < 0.00001 )

  1061.     		{

  1062.     			m_bChTrigMute[ kb ] = false;

  1063.     			m_pButtonChTrigMute[ kb ]->Set( false );

  1064.     		}

  1065.         }

  1066. 

  1067.         // if no keyboard clock active then use kb 0's clock

  1068.         if( !inputs[ IN_PATTERN_TRIG + kb ].active && inputs[ IN_PATTERN_TRIG + 0 ].active )

  1069.             useclock = 0;

  1070. 

  1071.         // phrase change trigger

  1072.         if( bGlobalPatChange && !m_bPause[ kb ] && inputs[ IN_PATTERN_TRIG + useclock ].active )

  1073.         {

  1074.             SetPendingPhrase( kb, -1 );

  1075.         }

  1076.         else if( inputs[ IN_PROG_CHANGE + kb ].active && !m_bPause[ kb ] && inputs[ IN_PATTERN_TRIG + useclock ].active )

  1077.         {

  1078. 	        if( m_SchTrigPhraseSelect[ kb ].process( inputs[ IN_PROG_CHANGE + kb ].value ) )

  1079.                 SetPendingPhrase( kb, -1 );

  1080.         }

  1081. 

  1082. 	    // pat change trigger - ignore if already pending

  1083.         if( inputs[ IN_PATTERN_TRIG + useclock ].active && !m_bPause[ kb ] )

  1084.         {

  1085.             if( PatTrig[ useclock ] ) 

  1086.             {

  1087.                 if( m_GlobalClkResetPending )

  1088.                 {

  1089.                     bGlobalClkTriggered = true;

  1090.                     m_CurrentPattern[ kb ] = -1;

  1091.                 }

  1092.                 else if( m_CurrentPattern[ kb ] >= ( m_nSteps[ kb ][ m_CurrentPhrase[ kb ] ] ) )

  1093.                 {

  1094.                     m_CurrentPattern[ kb ] = (nPATTERNS - 1);

  1095.                 }

  1096. 

  1097.                 ChangePattern( kb, m_CurrentPattern[ kb ] + 1, true, true );

  1098. 

  1099.                 if( m_CurrentPattern[ kb ] == 0 )

  1100.                 {

  1101.                     if( m_PhrasePending[ kb ].bPending )

  1102.                     {

  1103.                         m_PhrasePending[ kb ].bPending = false;

  1104.                         ChangePhrase( kb, m_PhrasePending[ kb ].phrase, false );

  1105.                     }

  1106.                 }

  1107.             }

  1108.         }

  1109.         else

  1110.         {

  1111.             // resolve any left over phrase triggers

  1112.             if( m_PhrasePending[ kb ].bPending )

  1113.             {

  1114.                 m_PhrasePending[ kb ].bPending = false;

  1115.                 ChangePhrase( kb, m_PhrasePending[ kb ].phrase, false );

  1116.             }

  1117.         }

  1118. 

  1119.         if( m_bTrig[ kb ] )

  1120.         {

  1121.             m_bTrig[ kb ] = false;

  1122.             m_gatePulse[ kb ].trigger( 0.050f );

  1123.         }

  1124. 

  1125.         trigout = m_gatePulse[ kb ].process( 1.0 / engineGetSampleRate() ) ? CV_MAX : 0.0;

  1126. 

  1127.         if( !m_bTrigMute && !m_bChTrigMute[ kb ] )

  1128.         	outputs[ OUT_TRIG + kb ].value = trigout;

  1129.         else

  1130.         	outputs[ OUT_TRIG + kb ].value = 0.0f;

  1131. 

  1132.         if( --m_glideCount[ kb ] > 0 )

  1133.             m_fglide[ kb ] -= m_fglideInc[ kb ];

  1134.         else

  1135.             m_fglide[ kb ] = 0.0;

  1136. 

  1137.         if( m_bTrigMute || m_bChTrigMute[ kb ] )

  1138.         	outputs[ OUT_VOCTS + kb ].value = flast[ kb ];

  1139.         else

  1140.         {

  1141.         	flast[ kb ] = ( m_fCvStartOut[ kb ] * m_fglide[ kb ] ) + ( m_fCvEndOut[ kb ] * ( 1.0 - m_fglide[ kb ] ) );

  1142.         	outputs[ OUT_VOCTS + kb ].value = flast[ kb ];

  1143.         }

  1144.     }

  1145. 

  1146.     if( bGlobalClkTriggered )

  1147.         m_GlobalClkResetPending = false;

  1148. }

  1149. 

  1150. } // namespace rack_plugin_mscHack

  1151. 

  1152. using namespace rack_plugin_mscHack;

  1153. 

  1154. RACK_PLUGIN_MODEL_INIT(mscHack, Seq_Triad2) {

  1155.    Model *modelSeq_Triad2 = Model::create<Seq_Triad2, Seq_Triad2_Widget>( "mscHack", "TriadSeq2", "SEQ Triad 2", SEQUENCER_TAG, MULTIPLE_TAG );

  1156.    return modelSeq_Triad2;

  1157. }