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.
994 Commits
4 Branches
541MB
Tree: 11ef40de16
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '11ef40de16'
${ noResults }
Rack/plugins/community/repos/mscHack/src/MasterClockx4.cpp

701 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, 0){}

  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 param, 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.                 param = paramId - MasterClockx4::PARAM_MULT;

  139. 

  140.                 if( mymodule->m_ChannelMultSelect[ param ] != (int)value )

  141.                 {

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

  143.                 }

  144.             }

  145. 

  146. 		    RoundKnob::onChange( e );

  147. 	    }

  148.     };

  149. 

  150.     // Overrides 

  151. 	void    step() override;

  152.     json_t* toJson() override;

  153.     void    fromJson(json_t *rootJ) override;

  154.     void    onReset() override;

  155. 

  156.     void    GetNewHumanizeVal( void );

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

  158.     void    CalcChannelClockRate( int ch );

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

  160. };

  161. 

  162. //-----------------------------------------------------

  163. // MyLEDButton_GlobalStop

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

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

  166. {

  167.     MasterClockx4 *mymodule;

  168.     mymodule = (MasterClockx4*)pClass;

  169.     mymodule->m_bGlobalStopState = bOn;

  170. }

  171. 

  172. //-----------------------------------------------------

  173. // MyLEDButton_TimeX2

  174. //-----------------------------------------------------

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

  176. {

  177.     MasterClockx4 *mymodule;

  178.     mymodule = (MasterClockx4*)pClass;

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

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

  181. }

  182. 

  183. //-----------------------------------------------------

  184. // MyLEDButton_GlobalTrig

  185. //-----------------------------------------------------

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

  187. {

  188.     MasterClockx4 *mymodule;

  189.     mymodule = (MasterClockx4*)pClass;

  190.     mymodule->m_bGlobalSync = true;

  191. }

  192. 

  193. //-----------------------------------------------------

  194. // MyLEDButton_ChannelStop

  195. //-----------------------------------------------------

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

  197. {

  198.     MasterClockx4 *mymodule;

  199.     mymodule = (MasterClockx4*)pClass;

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

  201. }

  202. 

  203. //-----------------------------------------------------

  204. // MyLEDButton_ChannelSync

  205. //-----------------------------------------------------

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

  207. {

  208.     MasterClockx4 *mymodule;

  209.     mymodule = (MasterClockx4*)pClass;

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

  211. 

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

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

  214. }

  215. 

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

  217. // Procedure:   Widget

  218. //

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

  220. 

  221. struct MasterClockx4_Widget : ModuleWidget {

  222. 	MasterClockx4_Widget( MasterClockx4 *module );

  223. };

  224. 

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

  226. {

  227.     int ch, x, y;

  228. 

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

  230. 

  231. 	{

  232. 		SVGPanel *panel = new SVGPanel();

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

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

  235. 		addChild(panel);

  236. 	}

  237. 

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

  239. 

  240.     // bpm knob

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

  242.     addParam( module->m_pBpmKnob );

  243. 

  244.     // bpm display

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

  246.     addChild( module->m_pDigitDisplayBPM );

  247. 

  248.     // global stop switch

  249.     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 );

  250. 	addChild( module->m_pButtonGlobalStop );

  251. 

  252.     // global sync button

  253.     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 );

  254. 	addChild( module->m_pButtonGlobalTrig );

  255. 

  256.     // humanize knob

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

  258.     addParam( module->m_pHumanKnob );

  259. 

  260.     // add chain out

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

  262. 

  263.     // chain in

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

  265. 

  266.     x = 91;

  267.     y = 39;

  268. 

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

  270.     {

  271.         // x2

  272.         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 );

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

  274. 

  275.         // clock mult knob

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

  277. 

  278.         // mult display

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

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

  281. 

  282.         // sync triggers

  283.         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 );

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

  285. 

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

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

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

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

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

  291. 

  292.         // clock out

  293.         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 );

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

  295. 

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

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

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

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

  300. 

  301.         y += 80;

  302.     }

  303. 

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

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

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

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

  308. 

  309.     module->m_bInitialized = true;

  310. 

  311.     module->onReset();

  312. }

  313. 

  314. //-----------------------------------------------------

  315. // Procedure:   

  316. //

  317. //-----------------------------------------------------

  318. json_t *MasterClockx4::toJson() 

  319. {

  320.     bool *pbool;

  321. 	json_t *rootJ = json_object();

  322.     json_t *gateJ;

  323. 

  324.     // m_bGlobalStopState

  325.     json_object_set_new( rootJ, "m_bGlobalStopState", json_boolean (m_bGlobalStopState) );

  326. 

  327. 	// m_bStopState

  328.     pbool = &m_bStopState[ 0 ];

  329. 

  330. 	json_t *gatesJ = json_array();

  331. 

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

  333.     {

  334. 		gateJ = json_boolean( (int) pbool[ i ] );

  335. 		json_array_append_new( gatesJ, gateJ );

  336. 	}

  337. 

  338. 	json_object_set_new( rootJ, "m_bStopState", gatesJ );

  339. 

  340. 	// m_bTimeX2

  341.     pbool = &m_bTimeX2[ 0 ];

  342. 

  343. 	gatesJ = json_array();

  344. 

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

  346.     {

  347. 		gateJ = json_boolean( (int) pbool[ i ] );

  348. 		json_array_append_new( gatesJ, gateJ );

  349. 	}

  350. 

  351. 	json_object_set_new( rootJ, "m_bTimeX2", gatesJ );

  352. 	return rootJ;

  353. }

  354. 

  355. //-----------------------------------------------------

  356. // Procedure:   fromJson

  357. //

  358. //-----------------------------------------------------

  359. void MasterClockx4::fromJson(json_t *rootJ) 

  360. {

  361.    bool *pbool;

  362.    json_t *gateJ;

  363. 

  364.     // m_bGlobalStopState

  365. 	json_t *revJ = json_object_get(rootJ, "m_bGlobalStopState");

  366. 

  367. 	if (revJ)

  368. 		m_bGlobalStopState = json_is_true( revJ );

  369. 

  370. 	// m_bPauseState

  371.     pbool = &m_bStopState[ 0 ];

  372. 

  373. 	json_t *StepsJ = json_object_get(rootJ, "m_bStopState");

  374. 

  375. 	if (StepsJ) 

  376.     {

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

  378.         {

  379. 			gateJ = json_array_get(StepsJ, i);

  380. 

  381. 			if (gateJ)

  382. 				pbool[ i ] = json_boolean_value( gateJ );

  383. 		}

  384. 	}

  385. 

  386. 	// m_bTimeX2

  387.     pbool = &m_bTimeX2[ 0 ];

  388. 

  389. 	StepsJ = json_object_get(rootJ, "m_bTimeX2");

  390. 

  391. 	if (StepsJ) 

  392.     {

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

  394.         {

  395. 			gateJ = json_array_get(StepsJ, i);

  396. 

  397. 			if (gateJ)

  398. 				pbool[ i ] = json_boolean_value( gateJ );

  399. 		}

  400. 	}

  401. 

  402. 

  403.     m_pButtonGlobalStop->Set( m_bGlobalStopState );

  404. 

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

  406.     {

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

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

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

  410.         SetDisplayLED( ch, (int)params[ PARAM_MULT + ch ].value );

  411.     }

  412. 

  413.     m_fMainClockCount = 0;

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

  415. 

  416.     if( m_pDigitDisplayBPM )

  417.         m_pDigitDisplayBPM->SetFloat( m_fBPM );

  418. }

  419. 

  420. //-----------------------------------------------------

  421. // Procedure:   reset

  422. //

  423. //-----------------------------------------------------

  424. void MasterClockx4::onReset()

  425. {

  426.     if( !m_bInitialized )

  427.         return;

  428. 

  429.     m_fBPM = 120;

  430. 

  431.     if( m_pDigitDisplayBPM )

  432.         m_pDigitDisplayBPM->SetFloat( m_fBPM );

  433. 

  434.     m_bGlobalStopState = false;

  435.     m_pButtonGlobalStop->Set( m_bGlobalStopState );

  436. 

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

  438.     {

  439.         m_bTimeX2[ ch ] = false;

  440.         m_bStopState[ ch ] = false;

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

  442.         SetDisplayLED( ch, MID_INDEX );

  443.     }

  444. 

  445.     BPMChange( m_fBPM, true );

  446. }

  447. 

  448. //-----------------------------------------------------

  449. // Procedure:   SetDisplayLED

  450. //

  451. //-----------------------------------------------------

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

  453. {

  454.     int col, mult = 1;

  455. 

  456.     if( !m_bInitialized )

  457.         return;

  458. 

  459.     if( m_bTimeX2[ ch ] )

  460.         mult = 2;

  461. 

  462.     if( val < MID_INDEX )

  463.     {

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

  465.     }

  466.     else if( val > MID_INDEX )

  467.     {

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

  469.     }

  470.     else

  471.     {

  472.         mult = 1;

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

  474.     }

  475. 

  476.     if( m_pDigitDisplayMult[ ch ] )

  477.     {

  478.         m_ChannelMultSelect[ ch ] = val;

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

  480. 

  481. 

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

  483.     }

  484. 

  485.     CalcChannelClockRate( ch );

  486. }

  487. 

  488. //-----------------------------------------------------

  489. // Procedure:   GetNewHumanizeVal

  490. //

  491. //-----------------------------------------------------

  492. void MasterClockx4::GetNewHumanizeVal( void )

  493. {

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

  495. 

  496.     if( randomUniform() > 0.5 )

  497.         m_fHumanize *= -1;

  498. }

  499. 

  500. //-----------------------------------------------------

  501. // Procedure:   BMPChange

  502. //

  503. //-----------------------------------------------------

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

  505. {

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

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

  508.         return;

  509. 

  510.     m_fBPM = fbpm;

  511.     m_fBeatsPers = fbpm / 60.0;

  512. 

  513.     if( m_pDigitDisplayBPM )

  514.        m_pDigitDisplayBPM->SetFloat( m_fBPM );

  515. 

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

  517.         CalcChannelClockRate( i );

  518. }

  519. 

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

  521. // Procedure:   CalcChannelClockRate

  522. //

  523. //-----------------------------------------------------

  524. void MasterClockx4::CalcChannelClockRate( int ch )

  525. {

  526.     int mult = 1;

  527. 

  528.     if( m_bTimeX2[ ch ] )

  529.         mult = 2;

  530. 

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

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

  533.         m_ChannelDivBeatCount[ ch ] = 1;

  534.     if( m_ChannelMultSelect[ ch ] <= MID_INDEX )

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

  536.     else

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

  538. }

  539. 

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

  541. // Procedure:   step

  542. //

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

  544. void MasterClockx4::step() 

  545. {

  546.     int ch, mult = 1;

  547.     float fSyncPulseOut, fClkPulseOut;

  548.     bool bMainClockTrig = false, bChannelClockTrig;

  549. 

  550.     if( !m_bInitialized )

  551.         return;

  552. 

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

  554.     if( inputs[ INPUT_CHAIN ].active )

  555.     {

  556.         if( !m_bWasChained )

  557.         {

  558.             m_pHumanKnob->visible = false;

  559.             m_pBpmKnob->visible = false;

  560.         }

  561. 

  562.         m_bWasChained = true;

  563. 

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

  565.         if( inputs[ INPUT_CHAIN ].value < 10.0 )

  566.         {

  567.             bMainClockTrig = true;

  568.         }

  569.         // values greater than zero are the bpm

  570.         else

  571.         {

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

  573.         }

  574.     }

  575.     else

  576.     {

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

  578.         if( m_bWasChained )

  579.         {

  580.             m_pHumanKnob->visible = true;

  581.             m_pBpmKnob->visible = true;

  582.             m_bWasChained = false;

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

  584.         }

  585. 

  586.         // keep track of main bpm

  587.         m_fMainClockCount += m_fBeatsPers;

  588.         if( ( m_fMainClockCount + m_fHumanize ) >= engineGetSampleRate() )

  589.         {

  590.             m_fMainClockCount = ( m_fMainClockCount + m_fHumanize ) - engineGetSampleRate();

  591. 

  592.             GetNewHumanizeVal();

  593. 

  594.             bMainClockTrig = true;

  595.         }

  596.     }

  597. 

  598.     // send chain

  599.     if( outputs[ OUTPUT_CHAIN ].active )

  600.     {

  601.         if( bMainClockTrig )

  602.             outputs[ OUTPUT_CHAIN ].value = -1.0;

  603.         else

  604.             outputs[ OUTPUT_CHAIN ].value = m_fBPM;

  605.     }

  606. 

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

  608.     {

  609.         bChannelClockTrig = false;

  610. 

  611.         // sync triggers

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

  613.         {

  614.             if( m_pButtonTrig[ ch ] )

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

  616. 

  617.             m_bChannelSyncPending[ ch ] = true;

  618.         }

  619. 

  620.         // sync all triggers to main clock pulse

  621.         if( bMainClockTrig )

  622.         {

  623.             if( m_bChannelSyncPending[ ch ] )

  624.             {

  625.                 if( m_pButtonTrig[ ch ] )

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

  627. 

  628.                 m_bChannelSyncPending[ ch ] = false;

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

  630. 

  631.                 m_ChannelDivBeatCount[ ch ] = 0;

  632.                 m_fChannelClockCount[ ch ] = 0;

  633.                 bChannelClockTrig = true;

  634.             }

  635.             else

  636.             {

  637.                 // divisions of clock will count beats

  638.                 if( m_ChannelMultSelect[ ch ] <= MID_INDEX )

  639.                 {

  640.                     if( m_bTimeX2[ ch ] )

  641.                         mult = 2;

  642. 

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

  644.                     {

  645.                         m_ChannelDivBeatCount[ ch ] = 0;

  646.                         bChannelClockTrig = true;

  647.                     }

  648.                 }

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

  650.                 else

  651.                 {

  652.                     m_fChannelClockCount[ ch ] = 0;

  653.                     bChannelClockTrig = true;

  654.                 }

  655.             }

  656.         }

  657.         // do multiple clocks

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

  659.         {

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

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

  662.             {

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

  664.                 bChannelClockTrig = true;

  665.             }

  666.         }

  667. 

  668.         if( bChannelClockTrig )

  669.             m_PulseClock[ ch ].trigger(1e-3);

  670. 

  671.         // syncs

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

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

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

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

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

  677. 

  678.         // clocks

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

  680. 

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

  682.         {

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

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

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

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

  687.         }

  688.     }

  689. 

  690.     m_bGlobalSync = false;

  691. }

  692. 

  693. } // namespace rack_plugin_mscHack

  694. 

  695. using namespace rack_plugin_mscHack;

  696. 

  697. RACK_PLUGIN_MODEL_INIT(mscHack, MasterClockx4) {

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

  699.    return modelMasterClockx4;

  700. }