VCVRack
/
Rack
mirror of https://github.com/VCVRack/Rack.git
1
0
Fork 0
Code Issues 0 Releases 43 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1221 Commits
4 Branches
611MB
Tree: 149eb47fe4
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '149eb47fe4'
${ noResults }
Rack/plugins/community/repos/mscHack/src/MasterClockx4.cpp

674 lines
21KB
Raw Blame History 

  1. #include "mscHack.hpp"

  2. //#include "mscHack_Controls.hpp"

  3. #include "dsp/digital.hpp"

  4. //#include "CLog.h"

  5. 

  6. namespace rack_plugin_mscHack {

  7. 

  8. #define nCHANNELS 4

  9. 

  10. #define MID_INDEX 12

  11. #define CLOCK_DIVS 25

  12. const int multdisplayval[ CLOCK_DIVS ] = { 32, 24, 16, 12, 9, 8, 7, 6, 5, 4, 3, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 16, 24, 32 };

  13. 

  14. //-----------------------------------------------------

  15. // Module Definition

  16. //

  17. //-----------------------------------------------------

  18. struct MasterClockx4 : Module 

  19. {

  20. 	enum ParamIds 

  21.     {

  22.         PARAM_BPM,

  23.         PARAM_MULT,

  24.         PARAM_HUMANIZE  = PARAM_MULT + nCHANNELS,

  25.         nPARAMS

  26.     };

  27. 

  28. 	enum InputIds 

  29.     {

  30.         INPUT_EXT_SYNC,

  31.         INPUT_CHAIN     = INPUT_EXT_SYNC + nCHANNELS,

  32.         nINPUTS         

  33. 	};

  34. 

  35. 	enum OutputIds 

  36.     {

  37.         OUTPUT_CLK,

  38.         OUTPUT_TRIG     = OUTPUT_CLK + ( nCHANNELS * 4 ),

  39.         OUTPUT_CHAIN    = OUTPUT_TRIG + ( nCHANNELS * 4 ),

  40.         nOUTPUTS

  41. 	};

  42. 

  43.     bool            m_bInitialized = false;

  44.     CLog            lg;

  45. 

  46.     float                m_fBPM = 120;

  47. 

  48.     MyLED7DigitDisplay  *m_pDigitDisplayMult[ nCHANNELS ] = {};

  49.     MyLED7DigitDisplay  *m_pDigitDisplayBPM  = NULL;

  50. 

  51.     MyLEDButton         *m_pButtonGlobalStop = NULL;

  52.     MyLEDButton         *m_pButtonGlobalTrig = NULL;

  53.     MyLEDButton         *m_pButtonStop[ nCHANNELS ] = {};

  54.     MyLEDButton         *m_pButtonTrig[ nCHANNELS ] = {};

  55.     MyLEDButton         *m_pButtonTimeX2[ nCHANNELS ] = {};

  56. 

  57.     bool                m_bGlobalSync = false;

  58.     bool                m_bStopState[ nCHANNELS ] = {};

  59.     bool                m_bGlobalStopState = false;

  60.     bool                m_bChannelSyncPending[ nCHANNELS ] = {};

  61.     bool                m_bTimeX2[ nCHANNELS ] = {};

  62. 

  63.     int                 m_ChannelDivBeatCount[ nCHANNELS ] = {};

  64.     float               m_fChannelBeatsPers[ nCHANNELS ] = {};

  65.     float               m_fChannelClockCount[ nCHANNELS ] = {};

  66.     int                 m_ChannelMultSelect[ nCHANNELS ] = {};

  67. 

  68.     float               m_fHumanize = 0;

  69.     float               m_bWasChained = false;

  70. 

  71.     float               m_fBeatsPers;

  72.     float               m_fMainClockCount;

  73. 

  74.     PulseGenerator      m_PulseClock[ nCHANNELS ];

  75.     PulseGenerator      m_PulseSync[ nCHANNELS ];

  76.     SchmittTrigger      m_SchmittSyncIn[ nCHANNELS ];

  77. 

  78.     ParamWidget        *m_pBpmKnob = NULL;

  79.     ParamWidget        *m_pHumanKnob = NULL;

  80. 

  81.     // Contructor

  82. 	MasterClockx4() : Module(nPARAMS, nINPUTS, nOUTPUTS){}

  83. 

  84.     //-----------------------------------------------------

  85.     // MyHumanize_Knob

  86.     //-----------------------------------------------------

  87.     struct MyHumanize_Knob : Knob_Yellow2_26

  88.     {

  89.         MasterClockx4 *mymodule;

  90. 

  91.         void onChange( EventChange &e ) override 

  92.         {

  93.             mymodule = (MasterClockx4*)module;

  94. 

  95.             if( mymodule && !mymodule->inputs[ INPUT_CHAIN ].active )

  96.                 mymodule->GetNewHumanizeVal();

  97. 

  98. 		    RoundKnob::onChange( e );

  99. 	    }

  100.     };

  101. 

  102.     //-----------------------------------------------------

  103.     // MyBPM_Knob

  104.     //-----------------------------------------------------

  105.     struct MyBPM_Knob : Knob_Yellow2_56

  106.     {

  107.         MasterClockx4 *mymodule;

  108. 

  109.         void onChange( EventChange &e ) override 

  110.         {

  111.             mymodule = (MasterClockx4*)module;

  112. 

  113.             if( mymodule && !mymodule->inputs[ INPUT_CHAIN ].active  )

  114.                 mymodule->BPMChange( value, false );

  115. 

  116. 		    RoundKnob::onChange( e );

  117. 	    }

  118.     };

  119. 

  120.     //-----------------------------------------------------

  121.     // MyMult_Knob

  122.     //-----------------------------------------------------

  123.     

  124.     struct MyMult_Knob : Knob_Yellow2_26_Snap

  125.     {

  126.         MasterClockx4 *mymodule;

  127.         int ch, col;

  128. 

  129.         void onChange( EventChange &e ) override 

  130.         {

  131.             mymodule = (MasterClockx4*)module;

  132. 

  133.             if( mymodule )

  134.             {

  135.                 //if( !mymodule->m_bInitialized )

  136.                     //return;

  137. 

  138.                 ch = paramId - MasterClockx4::PARAM_MULT;

  139. 

  140.                 //if( ch >= 0 && ch <= 3 )

  141.                 //{

  142.                     mymodule->SetDisplayLED( ch, (int)value );

  143.                 //}

  144.             }

  145. 

  146. 		    RoundKnob::onChange( e );

  147. 	    }

  148.     };

  149. 

  150.     // Overrides 

  151. 	void    step() override;

  152.     void    JsonParams( bool bTo, json_t *root);

  153.     json_t* toJson() override;

  154.     void    fromJson(json_t *rootJ) override;

  155.     void    onReset() override;

  156. 

  157.     void    GetNewHumanizeVal( void );

  158.     void    BPMChange( float fbmp, bool bforce );

  159.     void    CalcChannelClockRate( int ch );

  160.     void    SetDisplayLED( int ch, int val );

  161. };

  162. 

  163. //-----------------------------------------------------

  164. // MyLEDButton_GlobalStop

  165. //-----------------------------------------------------

  166. void MyLEDButton_GlobalStop( void *pClass, int id, bool bOn ) 

  167. {

  168.     MasterClockx4 *mymodule;

  169.     mymodule = (MasterClockx4*)pClass;

  170.     mymodule->m_bGlobalStopState = bOn;

  171. }

  172. 

  173. //-----------------------------------------------------

  174. // MyLEDButton_TimeX2

  175. //-----------------------------------------------------

  176. void MyLEDButton_TimeX2( void *pClass, int id, bool bOn ) 

  177. {

  178.     MasterClockx4 *mymodule;

  179.     mymodule = (MasterClockx4*)pClass;

  180.     mymodule->m_bTimeX2[ id ] = bOn;

  181.     mymodule->SetDisplayLED( id, (int)mymodule->params[ MasterClockx4::PARAM_MULT + id ].value );

  182. }

  183. 

  184. //-----------------------------------------------------

  185. // MyLEDButton_GlobalTrig

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

  187. void MyLEDButton_GlobalTrig( void *pClass, int id, bool bOn ) 

  188. {

  189.     MasterClockx4 *mymodule;

  190.     mymodule = (MasterClockx4*)pClass;

  191.     mymodule->m_bGlobalSync = true;

  192. }

  193. 

  194. //-----------------------------------------------------

  195. // MyLEDButton_ChannelStop

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

  197. void MyLEDButton_ChannelStop ( void *pClass, int id, bool bOn ) 

  198. {

  199.     MasterClockx4 *mymodule;

  200.     mymodule = (MasterClockx4*)pClass;

  201.     mymodule->m_bStopState[ id ] = bOn;

  202. }

  203. 

  204. //-----------------------------------------------------

  205. // MyLEDButton_ChannelSync

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

  207. void MyLEDButton_ChannelSync( void *pClass, int id, bool bOn ) 

  208. {

  209.     MasterClockx4 *mymodule;

  210.     mymodule = (MasterClockx4*)pClass;

  211.     mymodule->m_bChannelSyncPending[ id ] = true;

  212. 

  213.     if( mymodule->m_pButtonTrig[ id ] )

  214.         mymodule->m_pButtonTrig[ id ]->Set( true );

  215. }

  216. 

  217. //-----------------------------------------------------

  218. // Procedure:   Widget

  219. //

  220. //-----------------------------------------------------

  221. 

  222. struct MasterClockx4_Widget : ModuleWidget {

  223. 	MasterClockx4_Widget( MasterClockx4 *module );

  224. };

  225. 

  226. MasterClockx4_Widget::MasterClockx4_Widget( MasterClockx4 *module ) : ModuleWidget(module) 

  227. {

  228.     int ch, x, y;

  229. 

  230. 	box.size = Vec( 15*18, 380);

  231. 

  232. 	{

  233. 		SVGPanel *panel = new SVGPanel();

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

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

  236. 		addChild(panel);

  237. 	}

  238. 

  239.     //module->lg.Open("MasterClockx4.txt");

  240. 

  241.     // bpm knob

  242.     module->m_pBpmKnob = ParamWidget::create<MasterClockx4::MyBPM_Knob>( Vec( 9, 50 ), module, MasterClockx4::PARAM_BPM, 60.0, 220.0, 120.0 );

  243.     addParam( module->m_pBpmKnob );

  244. 

  245.     // bpm display

  246.     module->m_pDigitDisplayBPM = new MyLED7DigitDisplay( 5, 115, 0.055, DWRGB( 0, 0, 0 ), DWRGB( 0xFF, 0xFF, 0xFF ), MyLED7DigitDisplay::TYPE_FLOAT, 5 );

  247.     addChild( module->m_pDigitDisplayBPM );

  248. 

  249.     // global stop switch

  250.     module->m_pButtonGlobalStop = new MyLEDButton( 22, 144, 25, 25, 20.0, DWRGB( 180, 180, 180 ), DWRGB( 255, 0, 0 ), MyLEDButton::TYPE_SWITCH, 0, module, MyLEDButton_GlobalStop );

  251. 	addChild( module->m_pButtonGlobalStop );

  252. 

  253.     // global sync button

  254.     module->m_pButtonGlobalTrig = new MyLEDButton( 22, 202, 25, 25, 20.0, DWRGB( 180, 180, 180 ), DWRGB( 0, 255, 255 ), MyLEDButton::TYPE_MOMENTARY, 0, module, MyLEDButton_GlobalTrig );

  255. 	addChild( module->m_pButtonGlobalTrig );

  256. 

  257.     // humanize knob

  258.     module->m_pHumanKnob = ParamWidget::create<MasterClockx4::MyHumanize_Knob>( Vec( 22, 235 ), module, MasterClockx4::PARAM_HUMANIZE, 0.0, 1.0, 0.0 );

  259.     addParam( module->m_pHumanKnob );

  260. 

  261.     // add chain out

  262.     addOutput(Port::create<MyPortOutSmall>( Vec( 30, 345 ), Port::OUTPUT, module, MasterClockx4::OUTPUT_CHAIN ) );

  263. 

  264.     // chain in

  265.     addInput(Port::create<MyPortInSmall>( Vec( 30, 13 ), Port::INPUT, module, MasterClockx4::INPUT_CHAIN ) );

  266. 

  267.     x = 91;

  268.     y = 39;

  269. 

  270.     for( ch = 0; ch < nCHANNELS; ch++ )

  271.     {

  272.         // x2

  273.         module->m_pButtonTimeX2[ ch ] = new MyLEDButton( x + 2, y + 2, 11, 11, 9.0, DWRGB( 180, 180, 180 ), DWRGB( 0, 255, 255 ), MyLEDButton::TYPE_SWITCH, ch, module, MyLEDButton_TimeX2 );

  274. 	    addChild( module->m_pButtonTimeX2[ ch ] );

  275. 

  276.         // clock mult knob

  277.         addParam(ParamWidget::create<MasterClockx4::MyMult_Knob>( Vec( x + 13, y + 13 ), module, MasterClockx4::PARAM_MULT + ch, 0.0f, (float)(CLOCK_DIVS - 1), (float)(MID_INDEX) ) );

  278. 

  279.         // mult display

  280.         module->m_pDigitDisplayMult[ ch ] = new MyLED7DigitDisplay( x + 10, y + 48, 0.07, DWRGB( 0, 0, 0 ), DWRGB( 0xFF, 0xFF, 0xFF ), MyLED7DigitDisplay::TYPE_INT, 2 );

  281.         addChild( module->m_pDigitDisplayMult[ ch ] );

  282. 

  283.         // sync triggers

  284.         module->m_pButtonTrig[ ch ] = new MyLEDButton( x + 76, y + 4, 19, 19, 15.0, DWRGB( 180, 180, 180 ), DWRGB( 0, 255, 255 ), MyLEDButton::TYPE_MOMENTARY, ch, module, MyLEDButton_ChannelSync );

  285. 	    addChild( module->m_pButtonTrig[ ch ] );

  286. 

  287.         addInput(Port::create<MyPortInSmall>( Vec( x + 54, y + 5 ), Port::INPUT, module, MasterClockx4::INPUT_EXT_SYNC + ch ) );

  288.         addOutput(Port::create<MyPortOutSmall>( Vec( x + 54, y + 31 ), Port::OUTPUT, module, MasterClockx4::OUTPUT_TRIG  + (ch * 4) + 0 ) );

  289.         addOutput(Port::create<MyPortOutSmall>( Vec( x + 54, y + 53 ), Port::OUTPUT, module, MasterClockx4::OUTPUT_TRIG + (ch * 4) + 1 ) );

  290.         addOutput(Port::create<MyPortOutSmall>( Vec( x + 77, y + 31 ), Port::OUTPUT, module, MasterClockx4::OUTPUT_TRIG + (ch * 4) + 2 ) );

  291.         addOutput(Port::create<MyPortOutSmall>( Vec( x + 77, y + 53 ), Port::OUTPUT, module, MasterClockx4::OUTPUT_TRIG + (ch * 4) + 3 ) );

  292. 

  293.         // clock out

  294.         module->m_pButtonStop[ ch ] = new MyLEDButton( x + 132, y + 4, 19, 19, 15.0, DWRGB( 180, 180, 180 ), DWRGB( 255, 0, 0 ), MyLEDButton::TYPE_SWITCH, ch, module, MyLEDButton_ChannelStop );

  295. 	    addChild( module->m_pButtonStop[ ch ] );

  296. 

  297.         addOutput(Port::create<MyPortOutSmall>( Vec( x + 107, y + 31 ), Port::OUTPUT, module, MasterClockx4::OUTPUT_CLK + (ch * 4) + 0 ) );

  298.         addOutput(Port::create<MyPortOutSmall>( Vec( x + 107, y + 53 ), Port::OUTPUT, module, MasterClockx4::OUTPUT_CLK + (ch * 4) + 1 ) );

  299.         addOutput(Port::create<MyPortOutSmall>( Vec( x + 130, y + 31 ), Port::OUTPUT, module, MasterClockx4::OUTPUT_CLK + (ch * 4) + 2 ) );

  300.         addOutput(Port::create<MyPortOutSmall>( Vec( x + 130, y + 53 ), Port::OUTPUT, module, MasterClockx4::OUTPUT_CLK + (ch * 4) + 3 ) );

  301. 

  302.         y += 80;

  303.     }

  304. 

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

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

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

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

  309. 

  310.     module->m_bInitialized = true;

  311. 

  312.     module->onReset();

  313. }

  314. 

  315. //-----------------------------------------------------

  316. // Procedure: JsonParams  

  317. //

  318. //-----------------------------------------------------

  319. void MasterClockx4::JsonParams( bool bTo, json_t *root) 

  320. {

  321.     JsonDataBool( bTo, "m_bGlobalStopState", root, &m_bGlobalStopState, 1 );

  322.     JsonDataBool( bTo, "m_bStopState", root, m_bStopState, nCHANNELS );

  323.     JsonDataBool( bTo, "m_bTimeX2", root, m_bTimeX2, nCHANNELS );

  324.     JsonDataInt ( bTo, "m_ChannelMultSelect", root, m_ChannelMultSelect, nCHANNELS );

  325. }

  326. 

  327. //-----------------------------------------------------

  328. // Procedure:   

  329. //

  330. //-----------------------------------------------------

  331. json_t *MasterClockx4::toJson() 

  332. {

  333. 

  334. 	json_t *root = json_object();

  335. 

  336.     if( !root )

  337.         return NULL;

  338. 

  339.     JsonParams( TOJSON, root );

  340.     

  341. 	return root;

  342. }

  343. 

  344. //-----------------------------------------------------

  345. // Procedure:   fromJson

  346. //

  347. //-----------------------------------------------------

  348. void MasterClockx4::fromJson(json_t *root) 

  349. {

  350.     JsonParams( FROMJSON, root );

  351. 

  352.     m_pButtonGlobalStop->Set( m_bGlobalStopState );

  353. 

  354.     for( int ch = 0; ch < nCHANNELS; ch++ )

  355.     {

  356.         m_pButtonStop[ ch ]->Set( m_bStopState[ ch ] );

  357.         m_pButtonTimeX2[ ch ]->Set( m_bTimeX2[ ch ] );

  358.         //lg.f( "value = %d\n", (int)params[ PARAM_MULT + ch ].value );

  359.         SetDisplayLED( ch, m_ChannelMultSelect[ ch ] );

  360.     }

  361. 

  362.     m_fMainClockCount = 0;

  363.     BPMChange( params[ PARAM_BPM ].value, true );

  364. 

  365.     if( m_pDigitDisplayBPM )

  366.         m_pDigitDisplayBPM->SetFloat( m_fBPM );

  367. }

  368. 

  369. //-----------------------------------------------------

  370. // Procedure:   reset

  371. //

  372. //-----------------------------------------------------

  373. void MasterClockx4::onReset()

  374. {

  375.     if( !m_bInitialized )

  376.         return;

  377. 

  378.     m_fBPM = 120;

  379. 

  380.     if( m_pDigitDisplayBPM )

  381.         m_pDigitDisplayBPM->SetFloat( m_fBPM );

  382. 

  383.     m_bGlobalStopState = false;

  384.     m_pButtonGlobalStop->Set( m_bGlobalStopState );

  385. 

  386.     for( int ch = 0; ch < nCHANNELS; ch++ )

  387.     {

  388.         m_bTimeX2[ ch ] = false;

  389.         m_bStopState[ ch ] = false;

  390.         m_pButtonStop[ ch ]->Set( false );

  391.         m_pButtonTimeX2[ ch ]->Set( false );

  392.         SetDisplayLED( ch, MID_INDEX );

  393.     }

  394. 

  395.     BPMChange( m_fBPM, true );

  396. }

  397. 

  398. //-----------------------------------------------------

  399. // Procedure:   SetDisplayLED

  400. //

  401. //-----------------------------------------------------

  402. void MasterClockx4::SetDisplayLED( int ch, int val )

  403. {

  404.     int col, mult = 1;

  405. 

  406.     if( !m_bInitialized )

  407.         return;

  408. 

  409.     if( m_bTimeX2[ ch ] )

  410.         mult = 2;

  411. 

  412.     if( val < MID_INDEX )

  413.     {

  414.         col = DWRGB( 0xFF, 0, 0 );

  415.     }

  416.     else if( val > MID_INDEX )

  417.     {

  418.         col = DWRGB( 0, 0xFF, 0xFF );

  419.     }

  420.     else

  421.     {

  422.         mult = 1;

  423.         col = DWRGB( 0xFF, 0xFF, 0xFF );

  424.     }

  425. 

  426.     if( m_pDigitDisplayMult[ ch ] )

  427.     {

  428.         m_ChannelMultSelect[ ch ] = val;

  429.         m_pDigitDisplayMult[ ch ]->SetLEDCol( col );

  430. 

  431. 

  432.         m_pDigitDisplayMult[ ch ]->SetInt( multdisplayval[ val ] * mult );

  433.     }

  434. 

  435.     CalcChannelClockRate( ch );

  436. }

  437. 

  438. //-----------------------------------------------------

  439. // Procedure:   GetNewHumanizeVal

  440. //

  441. //-----------------------------------------------------

  442. void MasterClockx4::GetNewHumanizeVal( void )

  443. {

  444.     m_fHumanize = randomUniform() * engineGetSampleRate() * 0.1 * params[ PARAM_HUMANIZE ].value;

  445. 

  446.     if( randomUniform() > 0.5 )

  447.         m_fHumanize *= -1;

  448. }

  449. 

  450. //-----------------------------------------------------

  451. // Procedure:   BMPChange

  452. //

  453. //-----------------------------------------------------

  454. void MasterClockx4::BPMChange( float fbpm, bool bforce )

  455. {

  456.     // don't change if it is already the same

  457.     if( !bforce && ( (int)(fbpm * 1000.0f ) == (int)(m_fBPM * 1000.0f ) ) )

  458.         return;

  459. 

  460.     m_fBPM = fbpm;

  461.     m_fBeatsPers = fbpm / 60.0;

  462. 

  463.     if( m_pDigitDisplayBPM )

  464.        m_pDigitDisplayBPM->SetFloat( m_fBPM );

  465. 

  466.     for( int i = 0; i < nCHANNELS; i++ )

  467.         CalcChannelClockRate( i );

  468. }

  469. 

  470. //-----------------------------------------------------

  471. // Procedure:   CalcChannelClockRate

  472. //

  473. //-----------------------------------------------------

  474. void MasterClockx4::CalcChannelClockRate( int ch )

  475. {

  476.     int mult = 1;

  477. 

  478.     if( m_bTimeX2[ ch ] )

  479.         mult = 2;

  480. 

  481.     // for beat division just keep a count of beats

  482.     if( m_ChannelMultSelect[ ch ] == MID_INDEX )

  483.         m_ChannelDivBeatCount[ ch ] = 1;

  484.     else if( m_ChannelMultSelect[ ch ] < MID_INDEX )

  485.         m_ChannelDivBeatCount[ ch ] = multdisplayval[ m_ChannelMultSelect[ ch ] ] * mult;

  486.     else

  487.         m_fChannelBeatsPers[ ch ] = m_fBeatsPers * (float)( multdisplayval[ m_ChannelMultSelect[ ch ] ] * mult );

  488. }

  489. 

  490. //-----------------------------------------------------

  491. // Procedure:   step

  492. //

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

  494. void MasterClockx4::step() 

  495. {

  496.     int ch, mult = 1;

  497.     unsigned int ival;

  498.     float fSyncPulseOut, fClkPulseOut;

  499.     bool bMainClockTrig = false, bChannelClockTrig;

  500. 

  501.     if( !m_bInitialized )

  502.         return;

  503. 

  504.     // use the input chain trigger for our clock

  505.     if( inputs[ INPUT_CHAIN ].active )

  506.     {

  507.         if( !m_bWasChained )

  508.         {

  509.             m_pHumanKnob->visible = false;

  510.             m_pBpmKnob->visible = false;

  511.         }

  512. 

  513.         m_bWasChained = true;

  514. 

  515.         // value of less than zero is a trig

  516.         if( inputs[ INPUT_CHAIN ].value < 8.0 )

  517.         {

  518. 			ival = (unsigned int)inputs[ INPUT_CHAIN ].value;

  519. 

  520. 			bMainClockTrig = ( ival & 1 );

  521. 

  522. 			m_bGlobalSync = ( ival & 2 );

  523. 

  524. 			m_bGlobalStopState = ( ival & 4 );

  525. 

  526. 			m_pButtonGlobalStop->Set( m_bGlobalStopState );

  527.         }

  528.         // values greater than zero are the bpm

  529.         else

  530.         {

  531.             BPMChange( inputs[ INPUT_CHAIN ].value, false );

  532.         }

  533.     }

  534.     else

  535.     {

  536.         // go back to our bpm if chain removed

  537.         if( m_bWasChained )

  538.         {

  539.             m_pHumanKnob->visible = true;

  540.             m_pBpmKnob->visible = true;

  541.             m_bWasChained = false;

  542.             BPMChange( params[ PARAM_BPM ].value, false );

  543.             m_pButtonGlobalStop->Set( m_bGlobalStopState );

  544.         }

  545. 

  546.         // keep track of main bpm

  547.         m_fMainClockCount += m_fBeatsPers;

  548.         //if( ( m_fMainClockCount + m_fHumanize ) >= engineGetSampleRate() )

  549.         if( m_fMainClockCount >= (engineGetSampleRate()-1) )

  550.         {

  551.             //m_fMainClockCount = ( m_fMainClockCount + m_fHumanize ) - engineGetSampleRate();

  552.         	m_fMainClockCount = m_fMainClockCount - (engineGetSampleRate()-1);

  553. 

  554.             GetNewHumanizeVal();

  555. 

  556.             bMainClockTrig = true;

  557.         }

  558.     }

  559. 

  560.     // send chain

  561.     if( outputs[ OUTPUT_CHAIN ].active )

  562.     {

  563.     	ival = 0;

  564. 

  565.         if( bMainClockTrig )

  566.         	ival |= 1;

  567. 

  568.         if( m_bGlobalSync )

  569.         	ival |= 2;

  570. 

  571.         if( m_bGlobalStopState )

  572.         	ival |= 4;

  573. 

  574.         if( ival )

  575.             outputs[ OUTPUT_CHAIN ].value = (float)ival;

  576.         else

  577.             outputs[ OUTPUT_CHAIN ].value = m_fBPM;

  578.     }

  579. 

  580.     for( ch = 0; ch < nCHANNELS; ch++ )

  581.     {

  582.         bChannelClockTrig = false;

  583. 

  584.         // sync triggers

  585.         if( m_bGlobalSync || m_SchmittSyncIn[ ch ].process( inputs[ INPUT_EXT_SYNC + ch ].value ) )

  586.         {

  587.             if( m_pButtonTrig[ ch ] )

  588.                 m_pButtonTrig[ ch ]->Set( true );

  589. 

  590.             m_bChannelSyncPending[ ch ] = true;

  591.         }

  592. 

  593.         // sync all triggers to main clock pulse

  594.         if( bMainClockTrig )

  595.         {

  596.             if( m_bChannelSyncPending[ ch ] )

  597.             {

  598.                 if( m_pButtonTrig[ ch ] )

  599.                     m_pButtonTrig[ ch ]->Set( true );

  600. 

  601.                 m_bChannelSyncPending[ ch ] = false;

  602.                 m_PulseSync[ ch ].trigger(1e-3);

  603. 

  604.                 m_ChannelDivBeatCount[ ch ] = 0;

  605.                 m_fChannelClockCount[ ch ] = 0;

  606.                 bChannelClockTrig = true;

  607.             }

  608.             else

  609.             {

  610.                 // divisions of clock will count beats

  611.                 if( m_ChannelMultSelect[ ch ] < MID_INDEX )

  612.                 {

  613.                     if( m_bTimeX2[ ch ] )

  614.                         mult = 2;

  615. 

  616.                     if( ++m_ChannelDivBeatCount[ ch ] >= ( multdisplayval[ m_ChannelMultSelect[ ch ] ] * mult ) )

  617.                     {

  618.                         m_ChannelDivBeatCount[ ch ] = 0;

  619.                         bChannelClockTrig = true;

  620.                     }

  621.                 }

  622.                 // multiples of clock will sync with every beat

  623.                 else

  624.                 {

  625.                     m_fChannelClockCount[ ch ] = 0;

  626.                     bChannelClockTrig = true;

  627.                 }

  628.             }

  629.         }

  630.         // do multiple clocks

  631.         else if( m_ChannelMultSelect[ ch ] > MID_INDEX )

  632.         {

  633.             m_fChannelClockCount[ ch ] += m_fChannelBeatsPers[ ch ];

  634.             if( m_fChannelClockCount[ ch ] >= engineGetSampleRate() )

  635.             {

  636.                 m_fChannelClockCount[ ch ] = m_fChannelClockCount[ ch ] - engineGetSampleRate();

  637.                 bChannelClockTrig = true;

  638.             }

  639.         }

  640. 

  641.         if( bChannelClockTrig )

  642.             m_PulseClock[ ch ].trigger( 0.050f );

  643. 

  644.         // syncs

  645.         fSyncPulseOut = m_PulseSync[ ch ].process( 1.0 / engineGetSampleRate() ) ? CV_MAX : 0.0;

  646.         outputs[ OUTPUT_TRIG + (ch * 4) + 0 ].value = fSyncPulseOut;

  647.         outputs[ OUTPUT_TRIG + (ch * 4) + 1 ].value = fSyncPulseOut;

  648.         outputs[ OUTPUT_TRIG + (ch * 4) + 2 ].value = fSyncPulseOut;

  649.         outputs[ OUTPUT_TRIG + (ch * 4) + 3 ].value = fSyncPulseOut;

  650. 

  651.         // clocks

  652.         fClkPulseOut = m_PulseClock[ ch ].process( 1.0 / engineGetSampleRate() ) ? CV_MAX : 0.0;

  653. 

  654.         if( !m_bGlobalStopState && !m_bStopState[ ch ] )

  655.         {

  656.             outputs[ OUTPUT_CLK + (ch * 4) + 0 ].value = fClkPulseOut;

  657.             outputs[ OUTPUT_CLK + (ch * 4) + 1 ].value = fClkPulseOut;

  658.             outputs[ OUTPUT_CLK + (ch * 4) + 2 ].value = fClkPulseOut;

  659.             outputs[ OUTPUT_CLK + (ch * 4) + 3 ].value = fClkPulseOut;

  660.         }

  661.     }

  662. 

  663.     m_bGlobalSync = false;

  664. }

  665. 

  666. } // namespace rack_plugin_mscHack

  667. 

  668. using namespace rack_plugin_mscHack;

  669. 

  670. RACK_PLUGIN_MODEL_INIT(mscHack, MasterClockx4) {

  671.    Model *modelMasterClockx4 = Model::create<MasterClockx4, MasterClockx4_Widget>( "mscHack", "MasterClockx4", "Master CLOCK x 4", CLOCK_TAG, QUAD_TAG );

  672.    return modelMasterClockx4;

  673. }