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.
1097 Commits
4 Branches
545MB
Tree: b3e3f20e83
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b3e3f20e83'
${ noResults }
Rack/plugins/community/repos/mscHack/src/SEQ_6x32x16.cpp

826 lines
27KB
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 6

  9. #define nSTEPS 32

  10. #define nPROG 16

  11. 

  12. typedef struct

  13. {

  14.     bool    bPending;

  15.     int     prog;

  16. }PHRASE_CHANGE_STRUCT;

  17. 

  18. //-----------------------------------------------------

  19. // Module Definition

  20. //

  21. //-----------------------------------------------------

  22. struct SEQ_6x32x16 : Module 

  23. {

  24. #define NO_COPY -1

  25. 

  26. 	enum ParamIds 

  27.     {

  28.         PARAM_CPY_NEXT,

  29.         PARAM_RAND          = PARAM_CPY_NEXT + nCHANNELS,

  30.         PARAM_PAUSE         = PARAM_RAND + nCHANNELS,

  31.         PARAM_BILEVEL       = PARAM_PAUSE + nCHANNELS,

  32.         PARAM_LVL1_KNOB     = PARAM_BILEVEL + nCHANNELS,

  33.         PARAM_LVL2_KNOB     = PARAM_LVL1_KNOB + nCHANNELS,

  34.         PARAM_LVL3_KNOB     = PARAM_LVL2_KNOB + nCHANNELS,

  35.         PARAM_LVL4_KNOB     = PARAM_LVL3_KNOB + nCHANNELS,

  36.         PARAM_LVL5_KNOB     = PARAM_LVL4_KNOB + nCHANNELS,

  37.         nPARAMS             = PARAM_LVL5_KNOB + nCHANNELS

  38.     };

  39. 

  40. 	enum InputIds 

  41.     {

  42.         IN_GLOBAL_CLK_RESET,

  43.         IN_GLOBAL_PAT_CHANGE,

  44.         IN_CLK,

  45.         IN_PAT_TRIG     	= IN_CLK + nCHANNELS,

  46. 		IN_GLOBAL_TRIG_MUTE = IN_PAT_TRIG + nCHANNELS,

  47.         nINPUTS

  48. 	};

  49. 

  50. 	enum OutputIds 

  51.     {

  52.         OUT_TRIG,

  53.         OUT_LEVEL    = OUT_TRIG + nCHANNELS,

  54.         OUT_BEAT1    = OUT_LEVEL + nCHANNELS,

  55.         nOUTPUTS     = OUT_BEAT1 + nCHANNELS

  56. 	};

  57. 

  58.     bool            m_bInitialized = false;

  59.     CLog            lg;

  60. 

  61.     bool            m_bPauseState[ nCHANNELS ] = {};

  62.     bool            m_bBiLevelState[ nCHANNELS ] = {};

  63. 

  64.     SinglePatternClocked32  *m_pPatternDisplay[ nCHANNELS ] = {};

  65.     int                     m_Pattern[ nCHANNELS ][ nPROG ][ nSTEPS ];

  66.     int                     m_MaxPat[ nCHANNELS ][ nPROG ] = {};

  67. 

  68.     PatternSelectStrip      *m_pProgramDisplay[ nCHANNELS ] = {};

  69.     int                     m_CurrentProg[ nCHANNELS ] = {};

  70.     int                     m_MaxProg[ nCHANNELS ] = {};

  71.     PHRASE_CHANGE_STRUCT    m_ProgPending[ nCHANNELS ] = {};

  72. 

  73.     SchmittTrigger          m_SchTrigClock[ nCHANNELS ];

  74.     SchmittTrigger          m_SchTrigProg[ nCHANNELS ];

  75.     SchmittTrigger          m_SchTrigGlobalClkReset;

  76.     SchmittTrigger          m_SchTrigGlobalProg;

  77. 

  78.     bool                    m_bTrig[ nCHANNELS ] = {};

  79.     PulseGenerator          m_gatePulse[ nCHANNELS ];

  80.     PulseGenerator          m_gateBeatPulse[ nCHANNELS ];

  81. 

  82.     // swing

  83.     //int                     m_SwingLen[ nCHANNELS ] = {0};

  84.     //int                     m_SwingCount[ nCHANNELS ] = {0};

  85.     int                     m_ClockTick[ nCHANNELS ] = {0};

  86. 

  87.     int                     m_CopySrc = NO_COPY;

  88. 

  89.     // trig mute

  90.     bool            		m_bTrigMute = false;

  91.     MyLEDButton     		*m_pButtonTrigMute = NULL;

  92. 

  93.     // buttons    

  94.     MyLEDButton             *m_pButtonPause[ nCHANNELS ] = {};

  95.     MyLEDButton             *m_pButtonCopy[ nCHANNELS ] = {};

  96.     MyLEDButton             *m_pButtonBiLevel[ nCHANNELS ] = {};

  97.     MyLEDButton             *m_pButtonRand[ nCHANNELS ] = {};

  98.     MyLEDButton             *m_pButtonAutoPat[ nCHANNELS ] = {};

  99.     MyLEDButton             *m_pButtonHoldCV[ nCHANNELS ] = {};

  100.     MyLEDButton             *m_pButtonClear[ nCHANNELS ] = {};

  101. 

  102.     bool                    m_bAutoPatChange[ nCHANNELS ] = {};

  103.     bool                    m_bHoldCVState[ nCHANNELS ] = {};

  104. 

  105.     float                   m_fCVRanges[ 3 ] = { 15.0f, 10.0f, 5.0f};

  106.     int                     m_RangeSelect = 0;

  107.     char                    m_strRange[ 10 ] = {0};

  108. 

  109. 	 float flast[ nCHANNELS ];

  110. 

  111.     // Contructor

  112. 	SEQ_6x32x16() : Module(nPARAMS, nINPUTS, nOUTPUTS, 0){}

  113. 

  114.     // Overrides 

  115. 	void    step() override;

  116.     json_t* toJson() override;

  117.     void    fromJson(json_t *rootJ) override;

  118.     void    onRandomize() override;

  119.     void    onReset() override;

  120. 

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

  122.     void    CpyNext( int ch );

  123.     void    Rand( int ch );

  124.     void    ChangeProg( int ch, int prog, bool force );

  125.     void    SetPendingProg( int ch, int prog );

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

  127. };

  128. 

  129. //-----------------------------------------------------

  130. // MyLEDButton_TrigMute

  131. //-----------------------------------------------------

  132. void MyLEDButton_TrigMute( void *pClass, int id, bool bOn )

  133. {

  134. 	SEQ_6x32x16 *mymodule;

  135.     mymodule = (SEQ_6x32x16*)pClass;

  136.     mymodule->m_bTrigMute = bOn;

  137. }

  138. 

  139. //-----------------------------------------------------

  140. // MyLEDButton_AutoPat

  141. //-----------------------------------------------------

  142. void MyLEDButton_AutoPat( void *pClass, int id, bool bOn ) 

  143. {

  144.     SEQ_6x32x16 *mymodule;

  145.     mymodule = (SEQ_6x32x16*)pClass;

  146.     mymodule->m_bAutoPatChange[ id ] = bOn;

  147. }

  148. 

  149. //-----------------------------------------------------

  150. // MyLEDButton_Pause

  151. //-----------------------------------------------------

  152. void MyLEDButton_Pause( void *pClass, int id, bool bOn ) 

  153. {

  154.     SEQ_6x32x16 *mymodule;

  155.     mymodule = (SEQ_6x32x16*)pClass;

  156.     mymodule->m_bPauseState[ id ] = bOn;

  157. }

  158. 

  159. //-----------------------------------------------------

  160. // MyLEDButton_HoldCV

  161. //-----------------------------------------------------

  162. void MyLEDButton_HoldCV( void *pClass, int id, bool bOn ) 

  163. {

  164.     SEQ_6x32x16 *mymodule;

  165.     mymodule = (SEQ_6x32x16*)pClass;

  166.     mymodule->m_bHoldCVState[ id ] = bOn;

  167. }

  168. 

  169. //-----------------------------------------------------

  170. // MyLEDButton_BiLevel

  171. //-----------------------------------------------------

  172. void MyLEDButton_BiLevel( void *pClass, int id, bool bOn ) 

  173. {

  174.     SEQ_6x32x16 *mymodule;

  175.     mymodule = (SEQ_6x32x16*)pClass;

  176.     mymodule->m_bBiLevelState[ id ] = bOn;

  177. }

  178. 

  179. //-----------------------------------------------------

  180. // MyLEDButton_CpyNxt

  181. //-----------------------------------------------------

  182. void MyLEDButton_CpyNxt( void *pClass, int id, bool bOn ) 

  183. {

  184.     SEQ_6x32x16 *mymodule;

  185.     mymodule = (SEQ_6x32x16*)pClass;

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

  187. }

  188. 

  189. //-----------------------------------------------------

  190. // MyLEDButton_Rand

  191. //-----------------------------------------------------

  192. void MyLEDButton_Rand( void *pClass, int id, bool bOn ) 

  193. {

  194.     SEQ_6x32x16 *mymodule;

  195.     mymodule = (SEQ_6x32x16*)pClass;

  196.     mymodule->Rand( id );

  197. }

  198. 

  199. //-----------------------------------------------------

  200. // MyLEDButton_Rand

  201. //-----------------------------------------------------

  202. void MyLEDButton_Clear( void *pClass, int id, bool bOn ) 

  203. {

  204.     SEQ_6x32x16 *mymodule;

  205.     mymodule = (SEQ_6x32x16*)pClass;

  206. 

  207.     for( int i = 0; i < nSTEPS; i++ )

  208.     {

  209.         mymodule->m_Pattern[ id ][ mymodule->m_CurrentProg[ id ] ][ i ] = 0;

  210.     }

  211. 

  212.     mymodule->m_pPatternDisplay[ id ]->SetPatAll( mymodule->m_Pattern[ id ][ mymodule->m_CurrentProg[ id ] ] );

  213. }

  214. 

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

  216. // Procedure:   PatternChangeCallback

  217. //

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

  219. void SEQ_6x32x16_PatternChangeCallback ( void *pClass, int ch, int pat, int level, int maxpat )

  220. {

  221.     SEQ_6x32x16 *mymodule = (SEQ_6x32x16 *)pClass;

  222. 

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

  224.         return;

  225. 

  226.     mymodule->m_MaxPat[ ch ][ mymodule->m_CurrentProg[ ch ] ] = maxpat;

  227.     mymodule->m_Pattern[ ch ][ mymodule->m_CurrentProg[ ch ] ] [ pat ] = level;

  228. }

  229. 

  230. //-----------------------------------------------------

  231. // Procedure:   ProgramChangeCallback

  232. //

  233. //-----------------------------------------------------

  234. void SEQ_6x32x16_ProgramChangeCallback ( void *pClass, int ch, int pat, int max )

  235. {

  236.     SEQ_6x32x16 *mymodule = (SEQ_6x32x16 *)pClass;

  237. 

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

  239.         return;

  240. 

  241.     if( mymodule->m_MaxProg[ ch ] != max )

  242.     {

  243.         mymodule->m_MaxProg[ ch ] = max;

  244.     }

  245.     else if( mymodule->m_CurrentProg[ ch ] == pat && mymodule->m_bPauseState[ ch ] && mymodule->m_CopySrc != NO_COPY )

  246.     {

  247.         mymodule->ChangeProg( ch, pat, true );

  248.     }

  249.     else if( mymodule->m_CurrentProg[ ch ] != pat )

  250.     {

  251.         if( !mymodule->m_bPauseState[ ch ] && mymodule->inputs[ SEQ_6x32x16::IN_CLK + ch ].active )

  252.             mymodule->SetPendingProg( ch, pat );

  253.         else

  254.             mymodule->ChangeProg( ch, pat, false );

  255.     }

  256. }

  257. 

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

  259. // Procedure:   Widget

  260. //

  261. //-----------------------------------------------------

  262. 

  263. struct SEQ_6x32x16_Widget : ModuleWidget 

  264. {

  265.     Menu *createContextMenu() override;

  266. 	SEQ_6x32x16_Widget( SEQ_6x32x16 *module );

  267. };

  268. 

  269. SEQ_6x32x16_Widget::SEQ_6x32x16_Widget( SEQ_6x32x16 *module ) : ModuleWidget(module) 

  270. {

  271.     int x, y, x2, y2;

  272.     ParamWidget *pWidget = NULL;

  273. 

  274. 	box.size = Vec( 15*41, 380);

  275. 

  276. 	{

  277. 		SVGPanel *panel = new SVGPanel();

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

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

  280. 		addChild(panel);

  281. 	}

  282. 

  283.     //module->lg.Open("SEQ_6x32x16.txt");

  284. 

  285.     x = 7;

  286.     y = 22;

  287. 

  288.     // global inputs

  289.     addInput(Port::create<MyPortInSmall>( Vec( 204, 357 ), Port::INPUT, module, SEQ_6x32x16::IN_GLOBAL_CLK_RESET ) );

  290.     addInput(Port::create<MyPortInSmall>( Vec( 90, 357 ), Port::INPUT, module, SEQ_6x32x16::IN_GLOBAL_PAT_CHANGE ) );

  291. 

  292.     // trig mute

  293.     module->m_pButtonTrigMute = new MyLEDButton( 491, 3, 15, 15, 13.0, DWRGB( 180, 180, 180 ), DWRGB( 255, 0, 0 ), MyLEDButton::TYPE_SWITCH, 0, module, MyLEDButton_TrigMute );

  294.     addChild( module->m_pButtonTrigMute );

  295. 

  296.     addInput(Port::create<MyPortInSmall>( Vec( 466, 1 ), Port::INPUT, module, SEQ_6x32x16::IN_GLOBAL_TRIG_MUTE ) );

  297. 

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

  299.     {

  300.         // inputs

  301.         addInput(Port::create<MyPortInSmall>( Vec( x + 6, y + 7 ), Port::INPUT, module, SEQ_6x32x16::IN_CLK + ch ) );

  302.         addInput(Port::create<MyPortInSmall>( Vec( x + 64, y + 31 ), Port::INPUT, module, SEQ_6x32x16::IN_PAT_TRIG + ch ) );

  303. 

  304.         // pattern display

  305.         module->m_pPatternDisplay[ ch ] = new SinglePatternClocked32( x + 39, y + 2, 13, 13, 5, 2, 7, DWRGB( 255, 128, 64 ), DWRGB( 18, 9, 0 ), DWRGB( 180, 75, 180 ), DWRGB( 80, 45, 80 ), nSTEPS, ch, module, SEQ_6x32x16_PatternChangeCallback );

  306. 	    addChild( module->m_pPatternDisplay[ ch ] );

  307. 

  308.         // program display

  309.         module->m_pProgramDisplay[ ch ] = new PatternSelectStrip( x + 106, y + 31, 9, 7, DWRGB( 180, 180, 0 ), DWRGB( 90, 90, 64 ), DWRGB( 0, 180, 200 ), DWRGB( 0, 90, 90 ), nPROG, ch, module, SEQ_6x32x16_ProgramChangeCallback );

  310. 	    addChild( module->m_pProgramDisplay[ ch ] );

  311. 

  312.         // add knobs

  313.         y2 = y + 34;

  314.         //pWidget = ParamWidget::create<Knob_Green1_15>( Vec( x + 374, y2 ), module, SEQ_6x32x16::PARAM_SWING_KNOB + ch, 0.0, 0.6, 0.0 );

  315. 

  316.         // removed for now

  317.         if( pWidget )

  318.         {

  319.             addParam( pWidget );

  320.             pWidget->visible = false;

  321.         }

  322. 

  323.         x2 = x + 447;

  324.         addParam(ParamWidget::create<Knob_Green1_15>( Vec( x2, y2 ), module, SEQ_6x32x16::PARAM_LVL1_KNOB + ch, 0.0, 1.0, 0.25 ) ); x2 += 19;

  325.         addParam(ParamWidget::create<Knob_Green1_15>( Vec( x2, y2 ), module, SEQ_6x32x16::PARAM_LVL2_KNOB + ch, 0.0, 1.0, 0.33 ) ); x2 += 19;

  326.         addParam(ParamWidget::create<Knob_Green1_15>( Vec( x2, y2 ), module, SEQ_6x32x16::PARAM_LVL3_KNOB + ch, 0.0, 1.0, 0.50 ) ); x2 += 19;

  327.         addParam(ParamWidget::create<Knob_Green1_15>( Vec( x2, y2 ), module, SEQ_6x32x16::PARAM_LVL4_KNOB + ch, 0.0, 1.0, 0.75 ) ); x2 += 19;

  328.         addParam(ParamWidget::create<Knob_Green1_15>( Vec( x2, y2 ), module, SEQ_6x32x16::PARAM_LVL5_KNOB + ch, 0.0, 1.0, 0.9 ) );

  329. 

  330.         // add buttons

  331.         module->m_pButtonAutoPat[ ch ] = new MyLEDButton( x + 55, y + 35, 9, 9, 6.0, DWRGB( 180, 180, 180 ), DWRGB( 0, 255, 0 ), MyLEDButton::TYPE_SWITCH, ch, module, MyLEDButton_AutoPat );

  332. 	    addChild( module->m_pButtonAutoPat[ ch ] );

  333. 

  334.         module->m_pButtonPause[ ch ] = new MyLEDButton( x + 26, y + 10, 11, 11, 8.0, DWRGB( 180, 180, 180 ), DWRGB( 255, 0, 0 ), MyLEDButton::TYPE_SWITCH, ch, module, MyLEDButton_Pause );

  335. 	    addChild( module->m_pButtonPause[ ch ] );

  336. 

  337.         y2 = y + 33;

  338.         module->m_pButtonCopy[ ch ] = new MyLEDButton( x + 290, y2, 11, 11, 8.0, DWRGB( 180, 180, 180 ), DWRGB( 0, 244, 244 ), MyLEDButton::TYPE_SWITCH, ch, module, MyLEDButton_CpyNxt );

  339. 	    addChild( module->m_pButtonCopy[ ch ] );

  340. 

  341.         module->m_pButtonRand[ ch ] = new MyLEDButton( x + 315, y2, 11, 11, 8.0, DWRGB( 180, 180, 180 ), DWRGB( 0, 244, 244 ), MyLEDButton::TYPE_MOMENTARY, ch, module, MyLEDButton_Rand );

  342. 	    addChild( module->m_pButtonRand[ ch ] );

  343. 

  344.         module->m_pButtonClear[ ch ] = new MyLEDButton( x + 340, y2, 11, 11, 8.0, DWRGB( 180, 180, 180 ), DWRGB( 0, 244, 244 ), MyLEDButton::TYPE_MOMENTARY, ch, module, MyLEDButton_Clear );

  345. 	    addChild( module->m_pButtonClear[ ch ] );

  346. 

  347.         module->m_pButtonHoldCV[ ch ] = new MyLEDButton( x + 405, y2, 11, 11, 8.0, DWRGB( 180, 180, 180 ), DWRGB( 0, 244, 244 ), MyLEDButton::TYPE_SWITCH, ch, module, MyLEDButton_HoldCV );

  348. 	    addChild( module->m_pButtonHoldCV[ ch ] );

  349. 

  350.         module->m_pButtonBiLevel[ ch ] = new MyLEDButton( x + 425, y2, 11, 11, 8.0, DWRGB( 180, 180, 180 ), DWRGB( 0, 244, 244 ), MyLEDButton::TYPE_SWITCH, ch, module, MyLEDButton_BiLevel );

  351. 	    addChild( module->m_pButtonBiLevel[ ch ] );

  352. 

  353.         // add outputs

  354.         addOutput(Port::create<MyPortOutSmall>( Vec( x + 580, y + 7 ), Port::OUTPUT, module, SEQ_6x32x16::OUT_TRIG + ch ) );

  355.         addOutput(Port::create<MyPortOutSmall>( Vec( x + 544, y + 33 ), Port::OUTPUT, module, SEQ_6x32x16::OUT_LEVEL + ch ) );

  356.         addOutput(Port::create<MyPortOutSmall>( Vec( x + 37, y + 31 ), Port::OUTPUT, module, SEQ_6x32x16::OUT_BEAT1 + ch ) );

  357. 

  358.         y += 56;

  359.     }

  360. 

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

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

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

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

  365. 

  366.     module->m_bInitialized = true;

  367. 

  368.     module->onReset();

  369. }

  370. 

  371. //-----------------------------------------------------

  372. // Procedure: JsonParams  

  373. //

  374. //-----------------------------------------------------

  375. void SEQ_6x32x16::JsonParams( bool bTo, json_t *root) 

  376. {

  377.     JsonDataBool    ( bTo, "m_bPauseState",     root, &m_bPauseState[ 0 ], nCHANNELS );

  378.     JsonDataBool    ( bTo, "m_bBiLevelState",   root, &m_bBiLevelState[ 0 ], nCHANNELS );

  379.     JsonDataInt     ( bTo, "m_Pattern",         root, &m_Pattern[ 0 ][ 0 ][ 0 ], nCHANNELS * nSTEPS * nPROG );

  380.     JsonDataInt     ( bTo, "m_MaxPat",          root, &m_MaxPat[ 0 ][ 0 ], nCHANNELS * nPROG );

  381.     JsonDataInt     ( bTo, "m_CurrentProg",     root, &m_CurrentProg[ 0 ], nCHANNELS );

  382.     JsonDataInt     ( bTo, "m_MaxProg",         root, &m_MaxProg[ 0 ], nCHANNELS );

  383.     JsonDataBool    ( bTo, "m_bAutoPatChange",  root, &m_bAutoPatChange[ 0 ], nCHANNELS );

  384.     JsonDataBool    ( bTo, "m_bHoldCVState",    root, &m_bHoldCVState[ 0 ], nCHANNELS );

  385.     JsonDataInt     ( bTo, "m_RangeSelect",     root, &m_RangeSelect, 1 );

  386.     JsonDataBool    ( bTo, "m_bTrigMute",       root, &m_bTrigMute, 1 );

  387. }

  388. 

  389. //-----------------------------------------------------

  390. // Procedure: toJson  

  391. //

  392. //-----------------------------------------------------

  393. json_t *SEQ_6x32x16::toJson() 

  394. {

  395. 	json_t *root = json_object();

  396. 

  397.     if( !root )

  398.         return NULL;

  399. 

  400.     JsonParams( TOJSON, root );

  401.     

  402. 	return root;

  403. }

  404. 

  405. //-----------------------------------------------------

  406. // Procedure:   fromJson

  407. //

  408. //-----------------------------------------------------

  409. void SEQ_6x32x16::fromJson( json_t *root ) 

  410. {

  411.     JsonParams( FROMJSON, root );

  412. 

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

  414.     {

  415.         m_pButtonAutoPat[ ch ]->Set( m_bAutoPatChange[ ch ] );

  416.         m_pButtonPause[ ch ]->Set( m_bPauseState[ ch ] );

  417.         m_pButtonBiLevel[ ch ]->Set( m_bBiLevelState[ ch ] );

  418.         m_pButtonHoldCV[ ch ]->Set( m_bHoldCVState[ ch ] );

  419. 

  420.         m_pPatternDisplay[ ch ]->SetPatAll( m_Pattern[ ch ][ m_CurrentProg[ ch ] ] );

  421.         m_pPatternDisplay[ ch ]->SetMax( m_MaxPat[ ch ][ m_CurrentProg[ ch ] ] );

  422. 

  423.         m_pProgramDisplay[ ch ]->SetPat( m_CurrentProg[ ch ], false );

  424.         m_pProgramDisplay[ ch ]->SetMax( m_MaxProg[ ch ] );

  425.     }

  426. 

  427. 	if( m_bTrigMute )

  428. 		m_pButtonTrigMute->Set( m_bTrigMute );

  429. 

  430.     sprintf( m_strRange, "%.1fV", m_fCVRanges[ m_RangeSelect ] );

  431. }

  432. 

  433. //-----------------------------------------------------

  434. // Procedure:   reset

  435. //

  436. //-----------------------------------------------------

  437. void SEQ_6x32x16::onReset()

  438. {

  439.     if( !m_bInitialized )

  440.         return;

  441. 

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

  443.     {

  444.         m_pButtonPause[ ch ]->Set( false );

  445.         m_pButtonBiLevel[ ch ]->Set( false );

  446.     }

  447. 

  448.     memset( m_bPauseState, 0, sizeof(m_bPauseState) );

  449.     memset( m_bBiLevelState, 0, sizeof(m_bBiLevelState) );

  450.     memset( m_Pattern, 0, sizeof(m_Pattern) );

  451.     memset( m_CurrentProg, 0, sizeof(m_CurrentProg) );

  452. 

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

  454.     {

  455.         for( int prog = 0; prog < nCHANNELS; prog++ )

  456.             m_MaxPat[ ch ][ prog ] = nSTEPS - 1;

  457. 

  458.         m_MaxProg[ ch ] = nPROG - 1;

  459. 

  460.         m_pPatternDisplay[ ch ]->SetPatAll( m_Pattern[ ch ][ 0 ] );

  461.         m_pPatternDisplay[ ch ]->SetMax( m_MaxPat[ ch ][ 0 ] );

  462. 

  463.         m_pProgramDisplay[ ch ]->SetPat( 0, false );

  464.         m_pProgramDisplay[ ch ]->SetMax( m_MaxProg[ ch ] );

  465. 

  466.         m_pPatternDisplay[ ch ]->SetPatAll( m_Pattern[ ch ][ m_CurrentProg[ ch ] ] );

  467. 

  468.         ChangeProg( ch, 0, true );

  469.     }

  470. }

  471. 

  472. //-----------------------------------------------------

  473. // Procedure:   randomize

  474. //

  475. //-----------------------------------------------------

  476. void SEQ_6x32x16::onRandomize()

  477. {

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

  479.     {

  480.         for( int p = 0; p < nPROG; p++ )

  481.         {

  482.             for( int i = 0; i < nSTEPS; i++ )

  483.             {

  484.                 m_Pattern[ ch ][ p ][ i ] = (int)(randomUniform() * 5.0 );

  485.             }

  486.         }

  487. 

  488.         m_pPatternDisplay[ ch ]->SetPatAll( m_Pattern[ ch ][ m_CurrentProg[ ch ] ] );

  489.     }

  490. }

  491. 

  492. //-----------------------------------------------------

  493. // Procedure:   Rand

  494. //

  495. //-----------------------------------------------------

  496. void SEQ_6x32x16::Rand( int ch )

  497. {

  498.     for( int i = 0; i < nSTEPS; i++ )

  499.     {

  500.         if( i <= m_MaxPat[ ch ][ m_CurrentProg[ ch ] ] && randomUniform() > 0.5f )

  501.             m_Pattern[ ch ][ m_CurrentProg[ ch ] ][ i ] = (int)(randomUniform() * 5.0 );

  502.         else

  503.             m_Pattern[ ch ][ m_CurrentProg[ ch ] ][ i ] = 0;

  504.     }

  505. 

  506.     m_pPatternDisplay[ ch ]->SetPatAll( m_Pattern[ ch ][ m_CurrentProg[ ch ] ] );

  507. }

  508. 

  509. //-----------------------------------------------------

  510. // Procedure:   CpyNext

  511. //

  512. //-----------------------------------------------------

  513. void SEQ_6x32x16::CpyNext( int ch )

  514. {

  515.     int next;

  516. 

  517.     next = m_CurrentProg[ ch ] + 1;

  518. 

  519.     if( next >= nPROG )

  520.         return;

  521. 

  522.     memcpy( m_Pattern[ ch ][ next ], m_Pattern[ ch ][ m_CurrentProg[ ch ] ], sizeof(int) * nSTEPS );

  523. 

  524.     if(m_bPauseState[ ch ] || !inputs[ SEQ_6x32x16::IN_CLK + ch ].active )

  525.         ChangeProg( ch, next, false );

  526. }

  527. 

  528. //-----------------------------------------------------

  529. // Procedure:   Copy

  530. //

  531. //-----------------------------------------------------

  532. void SEQ_6x32x16::Copy( int ch, bool bOn )

  533. {

  534.     if( !m_bPauseState[ ch ] || !bOn || m_CopySrc != NO_COPY )

  535.     {

  536.         if( m_CopySrc != NO_COPY )

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

  538. 

  539.         m_CopySrc = NO_COPY;

  540.         m_pButtonCopy[ ch ]->Set( false );

  541.     }

  542.     else if( bOn )

  543.     {

  544.         m_CopySrc = ch;

  545.     }

  546. }

  547. 

  548. //-----------------------------------------------------

  549. // Procedure:   ChangProg

  550. //

  551. //-----------------------------------------------------

  552. void SEQ_6x32x16::ChangeProg( int ch, int prog, bool bforce )

  553. {

  554.     if( ch < 0 || ch >= nCHANNELS )

  555.         return;

  556. 

  557.     if( !bforce && prog == m_CurrentProg[ ch ] )

  558.         return;

  559. 

  560.     if( prog < 0 )

  561.         prog = nPROG - 1;

  562.     else if( prog >= nPROG )

  563.         prog = 0;

  564. 

  565.     if( m_CopySrc != NO_COPY )

  566.     {

  567.         if( m_bPauseState[ ch ] )

  568.         {

  569.             memcpy( m_Pattern[ ch ][ prog ], m_Pattern[ m_CopySrc ][ m_CurrentProg[ m_CopySrc ] ], sizeof(int) * nSTEPS );

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

  571.             m_MaxPat[ ch ][ prog ] = m_MaxPat[ m_CopySrc ][ m_CurrentProg[ m_CopySrc ] ];

  572.             m_CopySrc = NO_COPY;

  573.         }

  574.     }

  575. 

  576.     m_CurrentProg[ ch ] = prog;

  577. 

  578.     m_pPatternDisplay[ ch ]->SetPatAll( m_Pattern[ ch ][ prog ] );

  579.     m_pPatternDisplay[ ch ]->SetMax( m_MaxPat[ ch ][ prog ] );

  580.     m_pProgramDisplay[ ch ]->SetPat( prog, false );

  581. }

  582. 

  583. //-----------------------------------------------------

  584. // Procedure:   SetPendingProg

  585. //

  586. //-----------------------------------------------------

  587. void SEQ_6x32x16::SetPendingProg( int ch, int progIn )

  588. {

  589.     int prog;

  590. 

  591.     if( progIn < 0 || progIn >= nPROG )

  592.         prog = ( m_CurrentProg[ ch ] + 1 ) & 0xF;

  593.     else

  594.         prog = progIn;

  595. 

  596.     if( prog > m_MaxProg[ ch ] )

  597.         prog = 0;

  598. 

  599.     m_ProgPending[ ch ].bPending = true;

  600.     m_ProgPending[ ch ].prog = prog;

  601.     m_pProgramDisplay[ ch ]->SetPat( m_CurrentProg[ ch ], false );

  602.     m_pProgramDisplay[ ch ]->SetPat( prog, true );

  603. }

  604. 

  605. //-----------------------------------------------------

  606. // Procedure:   step

  607. //

  608. //-----------------------------------------------------

  609. void SEQ_6x32x16::step() 

  610. {

  611.     int ch, level, useclock;

  612.     bool bClk, bClkTrig, bClockAtZero = false, bGlobalClk = false, bGlobalProg = false, bTrigOut, bPatTrig[ nCHANNELS ] = {};

  613.     float fout = 0.0;

  614. 

  615.     if( !m_bInitialized )

  616.         return;

  617. 

  618.     if( inputs[ IN_GLOBAL_TRIG_MUTE ].active )

  619.     {

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

  621. 		{

  622. 			m_bTrigMute = true;

  623. 			m_pButtonTrigMute->Set( true );

  624. 		}

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

  626. 		{

  627. 			m_bTrigMute = false;

  628. 			m_pButtonTrigMute->Set( false );

  629. 		}

  630.     }

  631. 

  632.     if( inputs[ IN_GLOBAL_CLK_RESET ].active )

  633.         bGlobalClk = m_SchTrigGlobalClkReset.process( inputs[ IN_GLOBAL_CLK_RESET ].value );

  634. 

  635.     if( inputs[ IN_GLOBAL_PAT_CHANGE ].active )

  636.         bGlobalProg= m_SchTrigGlobalProg.process( inputs[ IN_GLOBAL_PAT_CHANGE ].value );

  637. 

  638.     // get trigs

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

  640.         bPatTrig[ ch ] = m_SchTrigClock[ ch ].process( inputs[ IN_CLK + ch ].normalize( 0.0f ) );

  641. 

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

  643.     {

  644.         bClkTrig = false;

  645.         bClk = false;

  646.         bTrigOut = false;

  647.         bClockAtZero = false;

  648.         useclock = ch;

  649. 

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

  651.         if( !inputs[ IN_CLK + ch ].active && inputs[ IN_CLK + 0 ].active )

  652.             useclock = 0;

  653. 

  654.         if( inputs[ IN_CLK + useclock ].active )

  655.         {

  656.             // time the clock tick

  657.             if( bGlobalClk )

  658.             {

  659.                 m_pPatternDisplay[ ch ]->ClockReset();

  660.                 bClkTrig = true;

  661.                 bClockAtZero = true;

  662.                 bClk = true;

  663.             }

  664. 

  665.             // clock

  666.             if( bPatTrig[ useclock ] && !bGlobalClk )

  667.                 bClkTrig = true;

  668. 

  669.             bClk = bClkTrig;

  670. 

  671.             // clock the pattern

  672.             if( !m_bPauseState[ ch ] )

  673.             {

  674.                 if( bGlobalProg || m_SchTrigProg[ ch ].process( inputs[ IN_PAT_TRIG + ch ].value ) )

  675.                     SetPendingProg( ch, -1 );

  676. 

  677.                 // clock in

  678.                 if( bClk )

  679.                 {

  680.                     if( !bGlobalClk )

  681.                         bClockAtZero = m_pPatternDisplay[ ch ]->ClockInc();

  682. 

  683.                     bTrigOut = ( m_Pattern[ ch ][ m_CurrentProg[ ch ] ][ m_pPatternDisplay[ ch ]->m_PatClk ] );

  684.                 }

  685.             }

  686.         }

  687.         // no clock input

  688.         else

  689.         {

  690.             // resolve any left over phrase triggers

  691.             if( m_ProgPending[ ch ].bPending )

  692.             {

  693.                 m_ProgPending[ ch ].bPending = false;

  694.                 ChangeProg( ch, m_ProgPending[ ch ].prog, true );

  695.             }

  696. 

  697.             continue;

  698.         }

  699. 

  700.         // auto inc pattern

  701.         if( m_bAutoPatChange[ ch ] && bClockAtZero )

  702.         {

  703.             SetPendingProg( ch, -1 );

  704.             m_ProgPending[ ch ].bPending = false;

  705.             ChangeProg( ch, m_ProgPending[ ch ].prog, true );

  706.             bTrigOut = ( m_Pattern[ ch ][ m_CurrentProg[ ch ] ][ m_pPatternDisplay[ ch ]->m_PatClk ] );

  707.         }

  708.         // resolve pattern change

  709.         else if( m_ProgPending[ ch ].bPending && bClockAtZero )

  710.         {

  711.             m_ProgPending[ ch ].bPending = false;

  712.             ChangeProg( ch, m_ProgPending[ ch ].prog, false );

  713.             bTrigOut = ( m_Pattern[ ch ][ m_CurrentProg[ ch ] ][ m_pPatternDisplay[ ch ]->m_PatClk ] );

  714.         }

  715. 

  716.         // trigger the beat 0 output

  717.         if( bClockAtZero )

  718.             m_gateBeatPulse[ ch ].trigger(1e-3);

  719. 

  720.         outputs[ OUT_BEAT1 + ch ].value = m_gateBeatPulse[ ch ].process( 1.0 / engineGetSampleRate() ) ? CV_MAX : 0.0;

  721. 

  722.         // trigger out

  723.         if( bTrigOut )

  724.         {

  725.             m_gatePulse[ ch ].trigger(1e-3);

  726.         }

  727. 

  728.         if( !m_bTrigMute )

  729.         	outputs[ OUT_TRIG + ch ].value = m_gatePulse[ ch ].process( 1.0 / engineGetSampleRate() ) ? CV_MAX : 0.0;

  730.         else

  731.         	outputs[ OUT_TRIG + ch ].value = 0.0f;

  732. 

  733.         level = m_Pattern[ ch ][ m_CurrentProg[ ch ] ][ m_pPatternDisplay[ ch ]->m_PatClk ];

  734. 

  735.         // get actual level from knobs

  736.         switch( level )

  737.         {

  738.         case 1:

  739.             fout = params[ PARAM_LVL1_KNOB + ch ].value;

  740.             break;

  741.         case 2:

  742.             fout = params[ PARAM_LVL2_KNOB + ch ].value;

  743.             break;

  744.         case 3:

  745.             fout = params[ PARAM_LVL3_KNOB + ch ].value;

  746.             break;

  747.         case 4:

  748.             fout = params[ PARAM_LVL4_KNOB + ch ].value;

  749.             break;

  750.         case 5:

  751.             fout = params[ PARAM_LVL5_KNOB + ch ].value;

  752.             break;

  753.         default:

  754.             if( m_bHoldCVState[ ch ] )

  755.                 continue;

  756.             else

  757.                 fout = 0.0f;

  758.         }

  759. 

  760.         // bidirectional convert to -1.0 to 1.0

  761.         if( m_bBiLevelState[ ch ] )

  762.             fout = ( fout * 2 ) - 1.0;

  763. 

  764.         if( m_bTrigMute )

  765.         	outputs[ OUT_LEVEL + ch ].value = flast[ ch ];

  766.         else

  767.         {

  768.         	flast[ ch ] = m_fCVRanges[ m_RangeSelect ] * fout;

  769.         	outputs[ OUT_LEVEL + ch ].value = flast[ ch ];

  770.         }

  771.     }

  772. }

  773. 

  774. //-----------------------------------------------------

  775. // Procedure:   SEQ_6x32x16_CVRange

  776. //

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

  778. struct SEQ_6x32x16_CVRange : MenuItem 

  779. {

  780.     SEQ_6x32x16 *module;

  781. 

  782.     void onAction(EventAction &e) override 

  783.     {

  784.         module->m_RangeSelect++;

  785. 

  786.         if( module->m_RangeSelect > 2 )

  787.             module->m_RangeSelect = 0;

  788. 

  789.         sprintf( module->m_strRange, "%.1fV", module->m_fCVRanges[ module->m_RangeSelect ] );

  790.     }

  791. 

  792.     void step() override 

  793.     {

  794.         rightText = module->m_strRange;

  795.     }

  796. };

  797. 

  798. //-----------------------------------------------------

  799. // Procedure:   createContextMenu

  800. //

  801. //-----------------------------------------------------

  802. Menu *SEQ_6x32x16_Widget::createContextMenu() 

  803. {

  804.     Menu *menu = ModuleWidget::createContextMenu();

  805. 

  806.     SEQ_6x32x16 *mod = dynamic_cast<SEQ_6x32x16*>(module);

  807. 

  808.     assert(mod);

  809. 

  810.     menu->addChild(construct<MenuLabel>());

  811. 

  812.     menu->addChild(construct<MenuLabel>(&MenuLabel::text, "---- CV Output Level ----"));

  813.     menu->addChild(construct<SEQ_6x32x16_CVRange>( &MenuItem::text, "VRange (15, 10, 5):", &SEQ_6x32x16_CVRange::module, mod ) );

  814. 

  815.     return menu;

  816. }

  817. 

  818. } // namespace rack_plugin_mscHack

  819. 

  820. using namespace rack_plugin_mscHack;

  821. 

  822. RACK_PLUGIN_MODEL_INIT(mscHack, SEQ_6x32x16) {

  823.    Model *modelSEQ_6x32x16 = Model::create<SEQ_6x32x16, SEQ_6x32x16_Widget>( "mscHack", "Seq_6ch_32step", "SEQ 6 x 32", SEQUENCER_TAG, MULTIPLE_TAG );

  824.    return modelSEQ_6x32x16;

  825. }