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
595MB
Tree: 37176f2064
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '37176f2064'
${ noResults }
Rack/plugins/community/repos/mscHack/src/Seq_3x16x16.cpp

1012 lines
29KB
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 PATTERNS 16

  9. #define STEPS    16

  10. #define CHANNELS 3

  11. #define LIGHT_LAMBDA ( 0.065f )

  12. #define CHANNEL_OFF_H 91

  13. 

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

  15. // Module Definition

  16. //

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

  18. struct Seq_3x16x16 : Module 

  19. {

  20. 	enum ParamIds 

  21.     {

  22.         PARAM_RAND,

  23.         PARAM_CPY_NEXT          = PARAM_RAND + CHANNELS,

  24. 		PARAM_RUN               = PARAM_CPY_NEXT + CHANNELS,

  25. 		PARAM_RESET,

  26. 		PARAM_SLIDERS,

  27. 		PARAM_STEPS             = PARAM_SLIDERS  + ( CHANNELS * STEPS ),

  28. 		PARAM_PATTERNS          = PARAM_STEPS    + ( CHANNELS * STEPS ),

  29.         PARAM_STEP_NUM          = PARAM_PATTERNS + ( CHANNELS * PATTERNS ),

  30.         PARAM_GLOBAL_PAT        = PARAM_STEP_NUM + ( STEPS ),

  31.         nPARAMS                 = PARAM_GLOBAL_PAT + ( PATTERNS )

  32.     };

  33. 

  34. 	enum InputIds 

  35.     {

  36. 		INPUT_EXT_CLOCK,

  37. 		INPUT_RESET,

  38.         INPUT_GLOBAL_PAT_CHANGE,

  39.         INPUT_PAT_CHANGE,

  40.         nINPUTS = INPUT_PAT_CHANGE + CHANNELS

  41. 	};

  42. 

  43. 	enum OutputIds 

  44.     {

  45. 		OUT_GATES,

  46.         OUT_CV      = OUT_GATES + CHANNELS,

  47.         nOUTPUTS    = OUT_CV + CHANNELS

  48. 	};

  49. 

  50. 	enum LightIds 

  51.     {

  52. 		LIGHT_RUN,

  53.         LIGHT_RESET,

  54.         LIGHT_STEP_NUM,

  55.         LIGHT_STEP          = LIGHT_STEP_NUM + ( STEPS ),

  56.         LIGHT_PAT           = LIGHT_STEP + ( CHANNELS * STEPS ),

  57.         LIGHT_COPY          = LIGHT_PAT + ( CHANNELS * PATTERNS ),

  58.         LIGHT_RAND          = LIGHT_COPY + CHANNELS,

  59.         LIGHT_GLOBAL_PAT    = LIGHT_RAND + CHANNELS,

  60.         nLIGHTS             = LIGHT_GLOBAL_PAT + PATTERNS

  61. 	};

  62. 

  63. 	enum GateMode 

  64.     {

  65. 		TRIGGER,

  66. 		RETRIGGER,

  67. 		CONTINUOUS,

  68. 	};

  69. 

  70.     CLog            lg;

  71.     bool            m_bInitJson = false;

  72. 	GateMode        m_GateMode = TRIGGER;

  73. 	PulseGenerator  m_PulseStep;

  74. 	bool            m_bRunning = true;

  75. 	float           m_fPhase = 0.0;

  76. 

  77.     // Inputs

  78. 	SchmittTrigger  m_SchTrigClock;

  79. 	SchmittTrigger  m_SchTrigRun;

  80. 	SchmittTrigger  m_SchTrigReset;

  81.     SchmittTrigger  m_SchTrigPatChange[ CHANNELS ];

  82. 

  83.     // random pattern button

  84.     SchmittTrigger  m_SchTrigRandPat;

  85. 

  86.     // copy next buttons

  87.     SchmittTrigger  m_SchTrigCopyNext;

  88. 

  89.     // number of steps

  90.     int             m_nSteps = STEPS;    

  91.     SchmittTrigger  m_SchTrigStepNumbers[ STEPS ];

  92.     

  93.     // Level settings

  94.     ParamWidget     *m_pLevelToggleParam2[ CHANNELS ][ STEPS ] = {};

  95.     SchmittTrigger  m_SchTrigLevels[ CHANNELS ][ STEPS ];

  96.     float           m_fLevels[ PATTERNS ][ CHANNELS ][ STEPS ] = {};

  97. 

  98.     // Global Pattern Select

  99.     SchmittTrigger  m_SchTrigGlobalPatternSelect;

  100.     int             m_GlobalSelect = 0;

  101.     bool            m_bGlobalPatternChangePending = false;

  102.     int             m_GlobalPendingLight = 0;

  103. 

  104.     // Pattern Select

  105.     int             m_PatternSelect[ CHANNELS ] = {0};    

  106.     SchmittTrigger  m_SchTrigPatternSelects[ CHANNELS ][ PATTERNS ];

  107.     bool            m_bPatternPending = false;

  108.     bool            m_bPatternChangePending[ CHANNELS ] = {0};

  109.     int             m_PendingLight[ CHANNELS ] = {0};

  110. 

  111.     // Steps

  112.     int             m_CurrentStep = 0;

  113.     SchmittTrigger  m_SchTrigSteps[ CHANNELS ][ STEPS ];

  114.     bool            m_bStepStates[ PATTERNS ][ CHANNELS ][ STEPS ] = {};    

  115.     float           m_fLightStepLevels[ CHANNELS ][ STEPS ] = {};

  116. 

  117.     // Contructor

  118. 	Seq_3x16x16() : Module( nPARAMS, nINPUTS, nOUTPUTS, nLIGHTS ){} 

  119. 

  120.     // Overrides 

  121. 	void    step() override;

  122.     json_t* toJson() override;

  123.     void    fromJson(json_t *rootJ) override;

  124.     void    onRandomize() override;

  125.     void    onReset() override;

  126. 

  127.     void Randomize_Channel( int ch );

  128.     void CopyNext( int ch );

  129.     void ChangePattern( int ch, int index, bool bForceChange );

  130.     void SetSteps( int nSteps );

  131.     void SetGlobalPattern( int step );

  132. };

  133. 

  134. //-----------------------------------------------------

  135. // Procedure:   MySquareButton_CopyNext

  136. //

  137. //-----------------------------------------------------

  138. struct MySquareButton_CopyNext : MySquareButton

  139. {

  140.     Seq_3x16x16 *mymodule;

  141.     int param;

  142. 

  143.     void onChange( EventChange &e ) override 

  144.     {

  145.         mymodule = (Seq_3x16x16*)module;

  146. 

  147.         if( mymodule && value == 1.0 )

  148.         {

  149.             param = paramId - Seq_3x16x16::PARAM_CPY_NEXT;

  150.             mymodule->CopyNext( param );

  151.         }

  152. 

  153. 		MomentarySwitch::onChange( e );

  154. 	}

  155. };

  156. 

  157. //-----------------------------------------------------

  158. // Procedure:   MySquareButton_Rand

  159. //

  160. //-----------------------------------------------------

  161. struct MySquareButton_Rand : MySquareButton

  162. {

  163.     Seq_3x16x16 *mymodule;

  164.     int param;

  165. 

  166.     void onChange( EventChange &e ) override 

  167.     {

  168.         mymodule = (Seq_3x16x16*)module;

  169. 

  170.         if( mymodule && value == 1.0 )

  171.         {

  172.             param = paramId - Seq_3x16x16::PARAM_RAND;

  173.             mymodule->Randomize_Channel( param );

  174.         }

  175. 

  176. 		MomentarySwitch::onChange( e );

  177. 	}

  178. };

  179. 

  180. //-----------------------------------------------------

  181. // Procedure:   MySquareButton_GlobalPattern

  182. //

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

  184. struct MySquareButton_GlobalPattern : MySquareButton //SVGSwitch, MomentarySwitch

  185. {

  186.     Seq_3x16x16 *mymodule;

  187.     int param;

  188. 

  189.     void onChange( EventChange &e ) override 

  190.     {

  191.         mymodule = (Seq_3x16x16*)module;

  192. 

  193.         if( mymodule && value == 1.0 )

  194.         {

  195.             param = paramId - Seq_3x16x16::PARAM_GLOBAL_PAT;

  196. 

  197.             if( mymodule->m_bRunning )

  198.             {

  199.                 if( param != mymodule->m_GlobalSelect && !mymodule->m_bGlobalPatternChangePending )

  200.                 {

  201.                     mymodule->m_bGlobalPatternChangePending = true;

  202.                     mymodule->m_GlobalPendingLight = param;

  203.                 }

  204.             }

  205.             else

  206.             {

  207.                 mymodule->SetGlobalPattern( param );

  208.             }

  209.         }

  210. 

  211. 		MomentarySwitch::onChange( e );

  212. 	}

  213. };

  214. 

  215. //-----------------------------------------------------

  216. // Procedure:   MySquareButton_Pattern

  217. //

  218. //-----------------------------------------------------

  219. struct MySquareButton_Pattern : MySquareButton //SVGSwitch, MomentarySwitch

  220. {

  221.     Seq_3x16x16 *mymodule;

  222.     int ch, stp, param;

  223. 

  224.     void onChange( EventChange &e ) override 

  225.     {

  226.         mymodule = (Seq_3x16x16*)module;

  227. 

  228.         if( mymodule && value == 1.0 )

  229.         {

  230.             param = paramId - Seq_3x16x16::PARAM_PATTERNS;

  231.             ch = param / STEPS;

  232.             stp = param - (ch * STEPS);

  233. 

  234.             //mymodule->lg.f( (char*)"pat = %d, ch = %d, stp = %d\n", param, ch, stp );

  235. 

  236.             if( mymodule->m_bRunning )

  237.             {

  238.                 if( stp != mymodule->m_PatternSelect[ ch ] && !mymodule->m_bPatternChangePending[ ch ] )

  239.                 {

  240.                     mymodule->m_bPatternPending = true;

  241.                     mymodule->m_bPatternChangePending[ ch ] = true;

  242.                     mymodule->m_PendingLight[ ch ] = stp;

  243.                 }

  244.             }

  245.             else

  246.             {

  247.                 mymodule->ChangePattern( ch, stp, false );

  248.             }

  249.         }

  250. 

  251. 		MomentarySwitch::onChange( e );

  252. 	}

  253. };

  254. 

  255. //-----------------------------------------------------

  256. // Procedure:   MySquareButton_Step

  257. //

  258. //-----------------------------------------------------

  259. struct MySquareButton_Step : MySquareButton //SVGSwitch, MomentarySwitch 

  260. {

  261.     Seq_3x16x16 *mymodule;

  262.     int ch, stp, param;

  263. 

  264.     void onChange( EventChange &e ) override 

  265.     {

  266.         mymodule = (Seq_3x16x16*)module;

  267. 

  268.         if( mymodule && value == 1.0 )

  269.         {

  270.             param = paramId - Seq_3x16x16::PARAM_STEPS;

  271.             ch = param / STEPS;

  272.             stp = param - (ch * STEPS);

  273. 

  274.             //lg.f( (char*)"step = %d, ch = %d, stp = %d\n", param, ch, stp );

  275.             mymodule->m_bStepStates[ mymodule->m_PatternSelect[ ch ] ][ ch ][ stp ] = !mymodule->m_bStepStates[ mymodule->m_PatternSelect[ ch ] ][ ch ][ stp ];

  276.             mymodule->lights[ Seq_3x16x16::LIGHT_STEP + ( ch * STEPS ) + stp ].value = mymodule->m_bStepStates[ mymodule->m_PatternSelect[ ch ] ][ ch ][ stp ] ? 1.0f : 0.0f;

  277.         }

  278. 

  279. 		MomentarySwitch::onChange( e );

  280. 	}

  281. };

  282. 

  283. //-----------------------------------------------------

  284. // Procedure:   MySquareButton_Step

  285. //

  286. //-----------------------------------------------------

  287. struct MySquareButton_StepNum : MySquareButton 

  288. {

  289.     Seq_3x16x16 *mymodule;

  290.     int stp, i;

  291. 

  292.     void onChange( EventChange &e ) override 

  293.     {

  294.         mymodule = (Seq_3x16x16*)module;

  295. 

  296.         if( mymodule && value == 1.0 )

  297.         {

  298.             stp = paramId - Seq_3x16x16::PARAM_STEP_NUM;

  299.             mymodule->SetSteps( stp + 1 );

  300.         }

  301. 

  302. 		MomentarySwitch::onChange( e );

  303. 	}

  304. };

  305. 

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

  307. // Procedure:   MySlider_Levels

  308. //

  309. //-----------------------------------------------------

  310. struct MySlider_Levels : MySlider_01

  311. {

  312.     Seq_3x16x16 *mymodule;

  313.     int ch, stp, param;

  314. 

  315.     void onChange( EventChange &e ) override 

  316.     {

  317.         mymodule = (Seq_3x16x16*)module;

  318. 

  319.         if( mymodule )

  320.         {

  321.             param = paramId - Seq_3x16x16::PARAM_SLIDERS;

  322.             ch = param / STEPS;

  323.             stp = param - (ch * STEPS);

  324. 

  325.             //lg.f( "slider = %d, ch = %d, stp = %d, value = %.3f\n", param, ch, stp, value );

  326. 

  327.             mymodule->m_fLevels[ mymodule->m_PatternSelect[ ch ] ][ ch ][ stp ] = value;

  328.         }

  329. 

  330.         SVGFader::onChange( e );

  331. 	}

  332. };

  333. 

  334. //-----------------------------------------------------

  335. // Procedure:   Widget

  336. //

  337. //-----------------------------------------------------

  338. 

  339. struct Seq_3x16x16_Widget : ModuleWidget {

  340. 	Seq_3x16x16_Widget( Seq_3x16x16 *module );

  341. };

  342. 

  343. Seq_3x16x16_Widget::Seq_3x16x16_Widget( Seq_3x16x16 *module ) : ModuleWidget(module) 

  344. {

  345.     int i, ch, stp, x, y;

  346. 

  347. 	box.size = Vec(15*23, 380);

  348. 

  349. 	{

  350. 		SVGPanel *panel = new SVGPanel();

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

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

  353. 		addChild(panel);

  354. 	}

  355. 

  356.     //module->lg.Open("Seq_3x16x16.txt");

  357. 

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

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

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

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

  362. 

  363.     // clk/run button

  364. 	addParam(ParamWidget::create<LEDButton>(Vec( 78, 17 ), module, Seq_3x16x16::PARAM_RUN, 0.0, 1.0, 0.0 ) );

  365.     addChild(ModuleLightWidget::create<SmallLight<GreenLight>>( Vec( 78 + 5, 17 + 5 ), module, Seq_3x16x16::LIGHT_RUN ) );

  366.     addInput(Port::create<MyPortInSmall>( Vec( 47, 17 ), Port::INPUT, module, Seq_3x16x16::INPUT_EXT_CLOCK ) );

  367. 

  368.     // reset button

  369. 	addParam(ParamWidget::create<LEDButton>( Vec( 143, 17 ), module, Seq_3x16x16::PARAM_RESET, 0.0, 1.0, 0.0 ) );

  370.     addChild(ModuleLightWidget::create<SmallLight<GreenLight>>( Vec( 143 + 5, 17 + 5 ), module, Seq_3x16x16::LIGHT_RESET ) );

  371.     addInput(Port::create<MyPortInSmall>( Vec( 117, 17 ), Port::INPUT, module, Seq_3x16x16::INPUT_RESET ) );

  372. 

  373.     //----------------------------------------------------

  374.     // Step Select buttons 

  375. 

  376.     y = 41;

  377.     x = 50;

  378. 

  379. 	for ( stp = 0; stp < STEPS; stp++ ) 

  380.     {

  381.         // step button

  382. 		addParam(ParamWidget::create<MySquareButton_StepNum>( Vec( x, y ), module, Seq_3x16x16::PARAM_STEP_NUM + stp, 0.0, 1.0, 0.0 ) );

  383.         addChild(ModuleLightWidget::create<SmallLight<DarkRedValueLight>>( Vec( x + 2, y + 3 ), module, Seq_3x16x16::LIGHT_STEP_NUM + stp ) );

  384. 

  385.         if( ( stp & 0x3 ) == 0x3 )

  386.             x += 20;

  387.         else

  388.             x += 15;

  389. 

  390.         module->lights[ Seq_3x16x16::LIGHT_STEP_NUM + stp ].value = 1.0;

  391.     }

  392. 

  393.     //----------------------------------------------------

  394.     // All the Channel buttons    

  395. 

  396.     // channel

  397. 	for ( ch = 0; ch < CHANNELS; ch++ ) 

  398.     {

  399.         x = 50;

  400. 

  401.         // step

  402. 	    for ( stp = 0; stp < STEPS; stp++ ) 

  403.         {

  404.             y = 64 + (ch * CHANNEL_OFF_H);

  405. 

  406.             // level button

  407. 		    module->m_pLevelToggleParam2[ ch ][ stp ] = ParamWidget::create<MySlider_Levels>( Vec( x, y ), module, Seq_3x16x16::PARAM_SLIDERS + ( ch * STEPS ) + stp , 0.0, 6.0, 0.0);

  408.             addParam( module->m_pLevelToggleParam2[ ch ][ stp ] );

  409. 

  410.             y += 46;

  411. 

  412.             // step button

  413. 		    addParam(ParamWidget::create<MySquareButton_Step>( Vec( x, y ), module, Seq_3x16x16::PARAM_STEPS + ( ch * STEPS ) + stp, 0.0, 1.0, 0.0 ) );

  414.             addChild(ModuleLightWidget::create<SmallLight<DarkGreenValueLight>>( Vec( x + 2, y + 3 ), module, Seq_3x16x16::LIGHT_STEP + ( ch * STEPS ) + stp ) );

  415. 

  416.             if( ( stp & 0x3 ) == 0x3 )

  417.                 x += 20;

  418.             else

  419.                 x += 15;

  420.         }

  421. 

  422.         x = 45;

  423.         y = 130 + (ch * CHANNEL_OFF_H);

  424. 

  425. 	    for ( i = 0; i < PATTERNS; i++ ) 

  426.         {

  427.             // pattern button

  428. 		    addParam(ParamWidget::create<MySquareButton_Pattern>( Vec( x, y ), module, Seq_3x16x16::PARAM_PATTERNS + ( ch * PATTERNS ) + i, 0.0, 1.0, 0.0 ) );

  429.             addChild(ModuleLightWidget::create<SmallLight<OrangeValueLight>>( Vec( x + 2, y + 3 ), module, Seq_3x16x16::LIGHT_PAT + ( ch * PATTERNS ) + i ) );

  430. 

  431.             x += 13;

  432.         }

  433. 

  434.         x = 260;

  435.         y = 126 + (ch * CHANNEL_OFF_H);

  436. 

  437.         // copy next button

  438. 		addParam(ParamWidget::create<MySquareButton_CopyNext>( Vec( x, y ), module, Seq_3x16x16::PARAM_CPY_NEXT + ch, 0.0, 1.0, 0.0 ) );

  439.         addChild(ModuleLightWidget::create<SmallLight<CyanValueLight>>( Vec( x + 2, y + 3 ), module, Seq_3x16x16::LIGHT_COPY + ch ) );

  440. 

  441.         x = 290;

  442. 

  443.         // random button

  444. 		addParam(ParamWidget::create<MySquareButton_Rand>( Vec( x, y ), module, Seq_3x16x16::PARAM_RAND + ch, 0.0, 1.0, 0.0 ) );

  445.         addChild(ModuleLightWidget::create<SmallLight<CyanValueLight>>( Vec( x + 2, y + 3 ), module, Seq_3x16x16::LIGHT_RAND + ch ) );

  446. 

  447.         // pattern change input trigger

  448.         addInput(Port::create<MyPortInSmall>( Vec( 17, 127 + (ch * CHANNEL_OFF_H) ), Port::INPUT, module, Seq_3x16x16::INPUT_PAT_CHANGE + ch ) );

  449. 

  450.         x = 310;

  451.         y = 65 + (ch * CHANNEL_OFF_H);

  452. 

  453.         // outputs

  454.         addOutput(Port::create<MyPortOutSmall>( Vec( x, y ), Port::OUTPUT, module, Seq_3x16x16::OUT_CV + ch ) );

  455.         addOutput(Port::create<MyPortOutSmall>( Vec( x, y + 42 ), Port::OUTPUT, module, Seq_3x16x16::OUT_GATES + ch ) );

  456. 	}

  457. 

  458.     //----------------------------------------------------

  459.     // Global patter select buttons  

  460.     x = 45;

  461.     y = 340;

  462. 

  463. 	for ( stp = 0; stp < PATTERNS; stp++ ) 

  464.     {

  465.         // pattern button

  466. 		addParam(ParamWidget::create<MySquareButton_GlobalPattern>( Vec( x, y ), module, Seq_3x16x16::PARAM_GLOBAL_PAT + stp, 0.0, 1.0, 0.0 ) );

  467.         addChild(ModuleLightWidget::create<SmallLight<OrangeValueLight>>( Vec( x + 2, y + 3 ), module, Seq_3x16x16::LIGHT_GLOBAL_PAT + stp ) );

  468. 

  469.         x += 13;

  470.     }

  471. 

  472.     // pattern change input trigger

  473.     addInput(Port::create<MyPortInSmall>( Vec( 17, 338 ), Port::INPUT, module, Seq_3x16x16::INPUT_GLOBAL_PAT_CHANGE ) );

  474. 

  475.     module->lights[ Seq_3x16x16::LIGHT_GLOBAL_PAT ].value = 1.0;

  476.     module->m_GlobalSelect = 0;

  477. 

  478.     module->ChangePattern( 0, PATTERNS, false );

  479.     module->ChangePattern( 1, PATTERNS, false );

  480.     module->ChangePattern( 2, PATTERNS, false );

  481. }

  482. 

  483. //-----------------------------------------------------

  484. // Procedure:   

  485. //

  486. //-----------------------------------------------------

  487. json_t *Seq_3x16x16::toJson() 

  488. {

  489.     bool *pgateState;

  490.     float *pfloat;

  491. 	json_t *rootJ = json_object();

  492. 

  493. 	// running

  494. 	json_object_set_new(rootJ, "running", json_boolean (m_bRunning));

  495. 

  496. 	// steps

  497.     pgateState = &m_bStepStates[ 0 ][ 0 ][ 0 ];

  498. 

  499. 	json_t *gatesJ = json_array();

  500. 

  501. 	for (int i = 0; i < ( PATTERNS * CHANNELS * STEPS ); i++)

  502.     {

  503. 		json_t *gateJ = json_integer( (int) pgateState[ i ] );

  504. 		json_array_append_new( gatesJ, gateJ );

  505. 	}

  506. 

  507. 	json_object_set_new( rootJ, "steps", gatesJ );

  508. 

  509.     // level settings

  510.     pfloat = &m_fLevels[ 0 ][ 0 ][ 0 ];

  511. 

  512. 	json_t *gatesJ_3 = json_array();

  513. 

  514. 	for (int i = 0; i < ( PATTERNS * CHANNELS * STEPS ); i++) 

  515.     {

  516. 		json_t *gateJ = json_real( pfloat[ i ] );

  517. 		json_array_append_new(gatesJ_3, gateJ);

  518. 	}

  519. 

  520. 	json_object_set_new(rootJ, "levelsettings", gatesJ_3);

  521. 

  522.     // number of steps

  523. 	json_t *stepsJ = json_integer( m_nSteps );

  524. 	json_object_set_new(rootJ, "numberofsteps", stepsJ);

  525. 

  526. 	// gateMode

  527. 	json_t *gateModeJ = json_integer((int) m_GateMode );

  528. 	json_object_set_new(rootJ, "gateMode", gateModeJ);

  529. 

  530. 	return rootJ;

  531. }

  532. 

  533. //-----------------------------------------------------

  534. // Procedure:   fromJson

  535. //

  536. //-----------------------------------------------------

  537. void Seq_3x16x16::fromJson(json_t *rootJ) 

  538. {

  539.     bool *pgateState;

  540.     float *pfloat;

  541. 

  542. 	// running

  543. 	json_t *runningJ = json_object_get(rootJ, "running");

  544. 

  545. 	if (runningJ)

  546. 		m_bRunning = json_is_true(runningJ);

  547. 

  548. 	// steps

  549.     pgateState = &m_bStepStates[ 0 ][ 0 ][ 0 ];

  550. 

  551. 	json_t *StepsJ = json_object_get(rootJ, "steps");

  552. 

  553. 	if (StepsJ) 

  554.     {

  555. 		for (int i = 0; i < ( PATTERNS * CHANNELS * STEPS ); i++)

  556.         {

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

  558. 

  559. 			if (gateJ)

  560. 				pgateState[ i ] = json_integer_value( gateJ );

  561. 		}

  562. 	}

  563. 

  564. 	// level settings

  565.     pfloat = &m_fLevels[ 0 ][ 0 ][ 0 ];

  566. 

  567. 	json_t *LvlSettingsJ = json_object_get(rootJ, "levelsettings");

  568. 

  569.     if (LvlSettingsJ) 

  570.     {

  571. 		for (int i = 0; i < ( PATTERNS * CHANNELS * STEPS ); i++) 

  572.         {

  573. 			json_t *gateJ = json_array_get(LvlSettingsJ, i);

  574. 

  575. 			if (gateJ)

  576. 				pfloat[ i ] = json_real_value(gateJ);

  577. 

  578.             //lg.f("loading %.3f\n", pfloat[ i ] );

  579. 		}

  580. 	}

  581. 

  582. 	// number of steps

  583. 	json_t *nStepsJ = json_object_get(rootJ, "numberofsteps");

  584. 	if (nStepsJ)

  585. 		m_nSteps = (GateMode)json_integer_value( nStepsJ );

  586. 

  587. 	// gateMode

  588. 	json_t *gateModeJ = json_object_get(rootJ, "gateMode");

  589. 	if (gateModeJ)

  590. 		m_GateMode = (GateMode)json_integer_value(gateModeJ);

  591. 

  592.     SetSteps( m_nSteps );

  593. 

  594.     //lg.f("json read complete\n");

  595.     m_bInitJson = true;

  596. }

  597. 

  598. //-----------------------------------------------------

  599. // Procedure:   reset

  600. //

  601. //-----------------------------------------------------

  602. void Seq_3x16x16::onReset()

  603. {

  604.     //lg.f("init\n");

  605.     memset( m_fLevels, 0, sizeof(m_fLevels) );

  606.     memset( m_bStepStates, 0, sizeof(m_bStepStates) );

  607. 

  608.     for( int ch = 0; ch < CHANNELS; ch ++ )

  609.     {

  610.         for( int i = 0; i < STEPS; i ++ )

  611.         {

  612.             lights[ LIGHT_STEP + ( ch * STEPS ) + i ].value = 0.0;

  613.             m_fLightStepLevels[ ch ][ i ] = 0.0;

  614.         }

  615.     }

  616. 

  617.     ChangePattern( 0, PATTERNS, false );

  618.     ChangePattern( 1, PATTERNS, false );

  619.     ChangePattern( 2, PATTERNS, false );

  620. 

  621.     SetSteps( 16 );

  622. }

  623. 

  624. //-----------------------------------------------------

  625. // Procedure:   randomize

  626. //

  627. //-----------------------------------------------------

  628. float stepchance[ 16 ] = { 0.9, 0.5, 0.8, 0.4, 0.9, 0.5, 0.8, 0.4, 0.9, 0.5, 0.8, 0.4, 0.9, 0.5, 0.8, 0.4 }; 

  629. void Seq_3x16x16::Randomize_Channel( int ch )

  630. {

  631.     int stp, pat;

  632.     int octave;

  633. 

  634.     pat = m_PatternSelect[ ch ];

  635. 

  636.     octave = (int)( randomUniform() * 4.0 );

  637. 

  638.     for( stp = 0; stp < STEPS; stp++ )

  639.     {

  640.         m_fLevels[ pat ][ ch ][ stp ] = (float)octave + ( randomUniform() * 2.0 );

  641.         m_bStepStates[ pat ][ ch ][ stp ] = ( randomUniform() < stepchance[ stp ] ) ? true : false;

  642.     }

  643. 

  644.     ChangePattern( ch, pat, true );

  645. }

  646. 

  647. //-----------------------------------------------------

  648. // Procedure:   randomize

  649. //

  650. //-----------------------------------------------------

  651. void Seq_3x16x16::onRandomize() 

  652. {

  653.     int ch, stp, pat;

  654.     int octave;

  655. 

  656.     for( ch = 0; ch < CHANNELS; ch++ )

  657.     {

  658.         for( pat = 0; pat < PATTERNS; pat++ )

  659.         {

  660.             octave = (int)( randomUniform() * 4.0 );

  661. 

  662.             for( stp = 0; stp < STEPS; stp++ )

  663.             {

  664.                 m_fLevels[ pat ][ ch ][ stp ] = (float)octave + ( randomUniform() * 2.0 );

  665.                 m_bStepStates[ pat ][ ch ][ stp ] = ( randomUniform() < stepchance[ stp ] ) ? true : false;

  666.             }

  667.         }

  668.     }

  669. 

  670.     ChangePattern( 0, 0, true );

  671.     ChangePattern( 1, 0, true );

  672.     ChangePattern( 2, 0, true );

  673. }

  674. 

  675. //-----------------------------------------------------

  676. // Procedure:   CopyNext

  677. //

  678. //-----------------------------------------------------

  679. void Seq_3x16x16::CopyNext( int ch )

  680. {

  681.     int stp, pat;

  682. 

  683.     pat = m_PatternSelect[ ch ];

  684. 

  685.     // don't copy from the last pattern

  686.     if( pat == (PATTERNS - 1) )

  687.         return;

  688. 

  689.     for( stp = 0; stp < STEPS; stp++ )

  690.     {

  691.         m_fLevels[ pat + 1 ][ ch ][ stp ] = m_fLevels[ pat ][ ch ][ stp ];

  692.         m_bStepStates[ pat + 1 ][ ch ][ stp ] = m_bStepStates[ pat ][ ch ][ stp ];

  693.     }

  694. 

  695.     ChangePattern( ch, pat + 1, true );

  696. }

  697. 

  698. //-----------------------------------------------------

  699. // Procedure:   ChangePattern

  700. //

  701. //-----------------------------------------------------

  702. void Seq_3x16x16::ChangePattern( int ch, int index, bool bForceChange )

  703. {

  704.     int stp, i;

  705. 

  706.     if( !bForceChange && index == m_PatternSelect[ ch ] )

  707.         return;

  708. 

  709.     if( index < 0 )

  710.         index = PATTERNS - 1;

  711.     else if( index >= PATTERNS )

  712.         index = 0;

  713. 

  714.     m_PatternSelect[ ch ] = index;

  715. 

  716.     // update lights

  717.     for( stp = 0; stp < STEPS; stp++ ) 

  718.         lights[ LIGHT_STEP + ( ch * STEPS ) + stp ].value = m_bStepStates[ m_PatternSelect[ ch ] ][ ch ][ stp ] ? 1.0 : 0.0;

  719. 

  720.     for( i = 0; i < PATTERNS; i++ )

  721.     {

  722.         if( m_PatternSelect[ ch ] == i )

  723.             lights[ LIGHT_PAT + ( ch * PATTERNS ) + i ].value = 1.0f; 

  724.         else

  725.             lights[ LIGHT_PAT + ( ch * PATTERNS ) + i ].value = 0.0f;

  726.     }

  727. 

  728.     // step

  729. 	for( stp = 0; stp < STEPS; stp++ ) 

  730.     {

  731.         // level button

  732. 		m_pLevelToggleParam2[ ch ][ stp ]->setValue( m_fLevels[ m_PatternSelect[ ch ] ][ ch ][ stp ] );

  733.     }

  734. }

  735. 

  736. //-----------------------------------------------------

  737. // Procedure:   SetSteps

  738. //

  739. //-----------------------------------------------------

  740. void Seq_3x16x16::SetSteps( int nSteps )

  741. {

  742.     int i;

  743. 

  744.     if( nSteps < 1 || nSteps > STEPS )

  745.         nSteps = STEPS;

  746. 

  747.     m_nSteps = nSteps;

  748. 

  749. 	for ( i = 0; i < STEPS; i++ ) 

  750.     {

  751.         // level button

  752. 		if( i < nSteps )

  753.             lights[ LIGHT_STEP_NUM + i ].value = 1.0f; 

  754.         else

  755.             lights[ LIGHT_STEP_NUM + i ].value = 0.0f;

  756.     }

  757. }

  758. 

  759. //-----------------------------------------------------

  760. // Procedure:   SetGlobalPattern

  761. //

  762. //-----------------------------------------------------

  763. void Seq_3x16x16::SetGlobalPattern( int step )

  764. {

  765. 	for ( int i = 0; i < PATTERNS; i++ ) 

  766.         lights[ LIGHT_GLOBAL_PAT + i ].value = 0.0f;

  767. 

  768.     lights[ LIGHT_GLOBAL_PAT + step ].value = 1.0;

  769. 

  770.     m_GlobalSelect = step;

  771. 

  772.     ChangePattern( 0, step, false );

  773.     ChangePattern( 1, step, false );

  774.     ChangePattern( 2, step, false );

  775. }

  776. 

  777. //-----------------------------------------------------

  778. // Procedure:   step

  779. //

  780. //-----------------------------------------------------

  781. void Seq_3x16x16::step() 

  782. {

  783.     bool bNextStep = false, bPulse, bGatesOn, bChTrig;

  784.     int ch, stp;

  785.     float fout, fnote;

  786.     int octave;

  787.     static float fpendinglight = 0.0f;

  788.     static bool bUp = true;

  789. 

  790.     // pending light value

  791.     if( bUp )

  792.     {

  793.         fpendinglight += ( 1.0 / engineGetSampleRate() ) * 1.5 ;

  794. 

  795.         if( fpendinglight >= 0.5f )

  796.         {

  797.             fpendinglight = 0.5f;

  798.             bUp = false;

  799.         }

  800.     }

  801.     else

  802.     {

  803.         fpendinglight -= ( 1.0 / engineGetSampleRate() ) * 2;

  804. 

  805.         if( fpendinglight <= 0.0f )

  806.         {

  807.             fpendinglight = 0.0f;

  808.             bUp = true;

  809.         }

  810.     }

  811. 

  812. 	// Run

  813. 	if( m_SchTrigRun.process( params[ PARAM_RUN ].value ) )

  814. 		m_bRunning = !m_bRunning;

  815. 

  816. 	lights[ LIGHT_RUN ].value = m_bRunning ? 1.0f : 0.0f;

  817. 

  818. 	// Random and copy buttons

  819. 	for( ch = 0; ch < CHANNELS; ch++ ) 

  820.     {

  821. 	    if( m_SchTrigRandPat.process( params[ PARAM_RAND + ch ].value ) ) 

  822.             lights[ LIGHT_RAND + ch ].value = 1.0f;

  823. 

  824. 	    if( m_SchTrigCopyNext.process( params[ PARAM_CPY_NEXT + ch ].value ) )

  825.             lights[ LIGHT_COPY + ch ].value = 1.0f;

  826. 

  827.         lights[ LIGHT_RAND + ch ].value -= lights[ LIGHT_RAND + ch ].value / LIGHT_LAMBDA / engineGetSampleRate();

  828. 

  829.         lights[ LIGHT_COPY + ch ].value -= lights[ LIGHT_COPY + ch ].value / LIGHT_LAMBDA / engineGetSampleRate();

  830.     }

  831. 

  832. 	if( m_bRunning ) 

  833.     {

  834. 		if( inputs[ INPUT_EXT_CLOCK ].active ) 

  835.         {

  836. 			// External clock

  837. 			if( m_SchTrigClock.process( inputs[ INPUT_EXT_CLOCK ].value ) ) 

  838.             {

  839. 				m_fPhase = 0.0f;

  840. 				bNextStep = true;

  841.     		}

  842. 		}

  843. 	}

  844.     else

  845.     {

  846.         // cancel any pending pattern changes

  847.         if( m_bGlobalPatternChangePending )

  848.         {

  849.             m_bGlobalPatternChangePending = false;

  850.             SetGlobalPattern( m_GlobalPendingLight );

  851.         }

  852. 

  853.         m_bPatternPending = false;

  854. 

  855.         for( ch = 0; ch < CHANNELS; ch++ )

  856.         {

  857. 	        // pat change trigger

  858. 	        if( m_bPatternChangePending[ ch ] )

  859.             {

  860.                 m_bPatternChangePending[ ch ] = false;

  861.                 ChangePattern( ch, m_PendingLight[ ch ], false );

  862.             }

  863.         }

  864.     }

  865. 

  866. 	// Reset

  867. 	if( m_SchTrigReset.process( params[ PARAM_RESET ].value + inputs[ INPUT_RESET ].value ) ) 

  868.     {

  869. 		m_fPhase = 0.0f;

  870. 		m_CurrentStep = m_nSteps;

  871. 		bNextStep = true;

  872.         lights[ LIGHT_RESET ].value = 1.0f;

  873. 	}

  874. 

  875. 	if( bNextStep ) 

  876.     {

  877. 		m_CurrentStep += 1;

  878. 

  879. 		if( m_CurrentStep >= m_nSteps ) 

  880. 			m_CurrentStep = 0;

  881. 

  882.         for( ch = 0; ch < CHANNELS; ch++ )

  883. 		    m_fLightStepLevels[ ch ][ m_CurrentStep ] = 1.0f;

  884. 

  885. 		m_PulseStep.trigger( 1e-3 );

  886. 

  887.         // resolve any pending pattern changes

  888.         if( m_CurrentStep == 0 )

  889.         {

  890.             if( m_bGlobalPatternChangePending )

  891.             {

  892.                 m_bGlobalPatternChangePending = false;

  893. 

  894.                 SetGlobalPattern( m_GlobalPendingLight );

  895. 

  896.                 // cancel other changes on a global change

  897.                 m_bPatternChangePending[ 0 ] = false;

  898.                 m_bPatternChangePending[ 1 ] = false;

  899.                 m_bPatternChangePending[ 2 ] = false;

  900.                 m_bPatternPending = false;

  901.             }

  902. 

  903.             for( ch = 0; ch < CHANNELS; ch++ )

  904.             {

  905. 	            // pat change trigger

  906. 	            if( m_bPatternChangePending[ ch ] )

  907.                 {

  908.                     m_bPatternChangePending[ ch ] = false;

  909.                     ChangePattern( ch, m_PendingLight[ ch ], false );

  910.                 }

  911.             }

  912.         }

  913. 	}

  914. 

  915.     // global pattern pending change light blinky

  916.     if( m_bGlobalPatternChangePending )

  917.     {

  918.         lights[ LIGHT_GLOBAL_PAT + m_GlobalPendingLight ].value = fpendinglight;

  919.     }

  920. 

  921.     // channel pattern pending change light blinky

  922.     if( m_bPatternPending )

  923.     {

  924.         m_bPatternPending = false;

  925. 

  926.         for( ch = 0; ch < CHANNELS; ch++ )

  927.         {

  928. 	        // pat change trigger

  929. 	        if( m_bPatternChangePending[ ch ] )

  930.             {

  931.                 m_bPatternPending = true;

  932.                 lights[ LIGHT_PAT + (ch * PATTERNS) + m_PendingLight[ ch ] ].value = fpendinglight;

  933.             }

  934.         }

  935.     }

  936. 

  937.    	lights[ LIGHT_RESET ].value -= lights[ LIGHT_RESET ].value / LIGHT_LAMBDA / engineGetSampleRate();

  938. 

  939. 	bPulse = m_PulseStep.process( 1.0 / engineGetSampleRate() );

  940. 

  941. 	// Step buttons

  942. 	for( ch = 0; ch < CHANNELS; ch++ ) 

  943.     {

  944.         bChTrig = false;

  945. 

  946. 	    for( stp = 0; stp < STEPS; stp++ ) 

  947.         {

  948. 		    bGatesOn = ( m_bRunning && stp == m_CurrentStep && m_bStepStates[ m_PatternSelect[ ch ] ][ ch ][ stp ] );

  949. 

  950. 		    if( m_GateMode == TRIGGER )

  951. 			    bGatesOn = bGatesOn && bPulse;

  952. 		    else if( m_GateMode == RETRIGGER )

  953. 			    bGatesOn = bGatesOn && !bPulse;

  954. 

  955.             if( bGatesOn )

  956.                 bChTrig = true;

  957. 		    

  958. 		    m_fLightStepLevels[ ch ][ stp ] -= m_fLightStepLevels[ ch ][ stp ] / LIGHT_LAMBDA / engineGetSampleRate();

  959. 

  960.             lights[ LIGHT_STEP + (ch * STEPS) + stp ].value = m_bStepStates[ m_PatternSelect[ ch ] ][ ch ][ stp ] ? 1.0 - m_fLightStepLevels[ ch ][ stp ] : m_fLightStepLevels[ ch ][ stp ];

  961. 	    }

  962. 

  963.         // trigger

  964.         outputs[ OUT_GATES + ch ].value = bChTrig ? CV_MAX : 0.0;

  965.     }

  966. 

  967.     // outputs

  968. 	for( ch = 0; ch < CHANNELS; ch++ ) 

  969.     {

  970.         // set CV

  971.         if( m_bRunning && m_bStepStates[ m_PatternSelect[ ch ] ][ ch ][ m_CurrentStep ]  )

  972.         {

  973.             // quantizie note

  974.             fout = params[ PARAM_SLIDERS + ( ch * STEPS ) + m_CurrentStep ].value;

  975.             octave = round( fout );

  976.             fnote   = round( ( fout - (float)octave ) * 12.0f );

  977.             outputs[ OUT_CV + ch ].value = (float)octave + fnote/12.0f;

  978.         }

  979.     }

  980. 

  981.     if( m_bRunning )

  982.     {

  983.         // external pattern select change

  984.         for( ch = 0; ch < CHANNELS; ch++ )

  985.         {

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

  987. 	        if( m_SchTrigPatChange[ ch ].process( inputs[ INPUT_PAT_CHANGE + ch ].value ) && !m_bPatternChangePending[ ch ] ) 

  988.             {

  989.                 m_bPatternPending = true;

  990.                 m_bPatternChangePending[ ch ] = true;

  991.                 m_PendingLight[ ch ] = ( m_PatternSelect[ ch ] + 1 ) & 0xF;

  992. 	        }

  993.         }

  994. 

  995. 	    // global pat change trigger - ignore if already pending

  996. 	    if( m_SchTrigGlobalPatternSelect.process( inputs[ INPUT_GLOBAL_PAT_CHANGE ].value ) && !m_bGlobalPatternChangePending ) 

  997.         {

  998.             m_bGlobalPatternChangePending = true;

  999.             m_GlobalPendingLight = ( m_GlobalSelect + 1 ) & 0xF;

  1000. 	    }

  1001.     }

  1002. }

  1003. 

  1004. } // namespace rack_plugin_mscHack

  1005. 

  1006. using namespace rack_plugin_mscHack;

  1007. 

  1008. RACK_PLUGIN_MODEL_INIT(mscHack, Seq_3x16x16) {

  1009.    Model *modelSeq_3x16x16 = Model::create<Seq_3x16x16, Seq_3x16x16_Widget>( "mscHack", "Seq_3ch_16step", "SEQ 3 x 16", SEQUENCER_TAG, MULTIPLE_TAG );

  1010.    return modelSeq_3x16x16;

  1011. }