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.
1304 Commits
4 Branches
541MB
Tree: e9f1388e73
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e9f1388e73'
${ noResults }
Rack/plugins/community/repos/ImpromptuModular/src/FoundrySequencerKernel.hpp

425 lines
18KB
Raw Blame History 

  1. //***********************************************************************************************

  2. //Impromptu Modular: Modules for VCV Rack by Marc Boulé

  3. //***********************************************************************************************

  4. 

  5. #ifndef FOUNDRY_SEQUENCER_KERNEL_HPP

  6. #define FOUNDRY_SEQUENCER_KERNEL_HPP

  7. 

  8. 

  9. #include "ImpromptuModular.hpp"

  10. 

  11. namespace rack_plugin_ImpromptuModular {

  12. 

  13. class StepAttributes {

  14. 	unsigned long attributes;

  15. 	

  16. 	public:

  17. 

  18. 	static const unsigned long ATT_MSK_GATE =      0x01000000, gateShift = 24;

  19. 	static const unsigned long ATT_MSK_GATEP =     0x02000000;

  20. 	static const unsigned long ATT_MSK_SLIDE =     0x04000000;

  21. 	static const unsigned long ATT_MSK_TIED =      0x08000000;

  22. 	static const unsigned long ATT_MSK_GATETYPE =  0xF0000000, gateTypeShift = 28;

  23. 	static const unsigned long ATT_MSK_VELOCITY =  0x000000FF, velocityShift = 0;

  24. 	static const unsigned long ATT_MSK_GATEP_VAL = 0x0000FF00, gatePValShift = 8;

  25. 	static const unsigned long ATT_MSK_SLIDE_VAL = 0x00FF0000, slideValShift = 16;

  26. 

  27. 	static const int INIT_VELOCITY = 100;

  28. 	static const int MAX_VELOCITY = 200;

  29. 	static const int INIT_PROB = 50;// range is 0 to 100

  30. 	static const int INIT_SLIDE = 10;// range is 0 to 100

  31. 	

  32. 	static const unsigned long ATT_MSK_INITSTATE = ((ATT_MSK_GATE) | (INIT_VELOCITY << velocityShift) | (INIT_PROB << gatePValShift) | (INIT_SLIDE << slideValShift));

  33. 

  34. 	inline void clear() {attributes = 0ul;}

  35. 	inline void init() {attributes = ATT_MSK_INITSTATE;}

  36. 	inline void randomize() {attributes = ( (randomu32() & (ATT_MSK_GATE | ATT_MSK_GATEP | ATT_MSK_SLIDE /*| ATT_MSK_TIED*/)) | ((randomu32() % 101) << gatePValShift) | ((randomu32() % 101) << slideValShift) | (randomu32() % (MAX_VELOCITY + 1)) ) ;}

  37. 	

  38. 	inline bool getGate() {return (attributes & ATT_MSK_GATE) != 0;}

  39. 	inline int getGateType() {return (int)((attributes & ATT_MSK_GATETYPE) >> gateTypeShift);}

  40. 	inline bool getTied() {return (attributes & ATT_MSK_TIED) != 0;}

  41. 	inline bool getGateP() {return (attributes & ATT_MSK_GATEP) != 0;}

  42. 	inline int getGatePVal() {return (int)((attributes & ATT_MSK_GATEP_VAL) >> gatePValShift);}

  43. 	inline bool getSlide() {return (attributes & ATT_MSK_SLIDE) != 0;}

  44. 	inline int getSlideVal() {return (int)((attributes & ATT_MSK_SLIDE_VAL) >> slideValShift);}

  45. 	inline int getVelocityVal() {return (int)((attributes & ATT_MSK_VELOCITY) >> velocityShift);}

  46. 	inline unsigned long getAttribute() {return attributes;}

  47. 

  48. 	inline void setGate(bool gate1State) {attributes &= ~ATT_MSK_GATE; if (gate1State) attributes |= ATT_MSK_GATE;}

  49. 	inline void setGateType(int gateType) {attributes &= ~ATT_MSK_GATETYPE; attributes |= (((unsigned long)gateType) << gateTypeShift);}

  50. 	inline void setTied(bool tiedState) {

  51. 		attributes &= ~ATT_MSK_TIED; 

  52. 		if (tiedState) {

  53. 			attributes |= ATT_MSK_TIED;

  54. 			attributes &= ~(ATT_MSK_GATE | ATT_MSK_GATEP | ATT_MSK_SLIDE);// clear other attributes if tied

  55. 		}

  56. 	}

  57. 	inline void setGateP(bool GatePState) {attributes &= ~ATT_MSK_GATEP; if (GatePState) attributes |= ATT_MSK_GATEP;}

  58. 	inline void setGatePVal(int gatePval) {attributes &= ~ATT_MSK_GATEP_VAL; attributes |= (((unsigned long)gatePval) << gatePValShift);}

  59. 	inline void setSlide(bool slideState) {attributes &= ~ATT_MSK_SLIDE; if (slideState) attributes |= ATT_MSK_SLIDE;}

  60. 	inline void setSlideVal(int slideVal) {attributes &= ~ATT_MSK_SLIDE_VAL; attributes |= (((unsigned long)slideVal) << slideValShift);}

  61. 	inline void setVelocityVal(int _velocity) {attributes &= ~ATT_MSK_VELOCITY; attributes |= (((unsigned long)_velocity) << velocityShift);}

  62. 	inline void setAttribute(unsigned long _attributes) {attributes = _attributes;}

  63. };// class StepAttributes

  64. 

  65. 

  66. //*****************************************************************************

  67. 

  68. 

  69. class Phrase {

  70. 	// a phrase is a sequence number and a number of repetitions; it is used to make a song

  71. 	unsigned long phrase;

  72. 	

  73. 	public:

  74. 

  75. 	static const unsigned long PHR_MSK_SEQNUM = 0x00FF;

  76. 	static const unsigned long PHR_MSK_REPS =   0xFF00, repShift = 8;// a rep is 0 to 99

  77. 	

  78. 	inline void init() {phrase = (1 << repShift);}

  79. 	inline void randomize(int maxSeqs) {phrase = ((randomu32() % maxSeqs) | ((randomu32() % 4 + 1) << repShift));}

  80. 	

  81. 	inline int getSeqNum() {return (int)(phrase & PHR_MSK_SEQNUM);}

  82. 	inline int getReps() {return (int)((phrase & PHR_MSK_REPS) >> repShift);}

  83. 	inline unsigned long getPhraseJson() {return phrase - (1 << repShift);}// compression trick (store 0 instead of 1)

  84. 	

  85. 	inline void setSeqNum(int seqn) {phrase &= ~PHR_MSK_SEQNUM; phrase |= ((unsigned long)seqn);}

  86. 	inline void setReps(int _reps) {phrase &= ~PHR_MSK_REPS; phrase |= (((unsigned long)_reps) << repShift);}

  87. 	inline void setPhraseJson(unsigned long _phrase) {phrase = (_phrase + (1 << repShift));}// compression trick (store 0 instead of 1)

  88. };// class Phrase

  89. 

  90. 

  91. //*****************************************************************************

  92. 

  93. 

  94. class SeqAttributes {

  95. 	unsigned long attributes;

  96. 	

  97. 	public:

  98. 

  99. 	static const unsigned long SEQ_MSK_LENGTH  =   0x000000FF;// number of steps in each sequence, min value is 1

  100. 	static const unsigned long SEQ_MSK_RUNMODE =   0x0000FF00, runModeShift = 8;

  101. 	static const unsigned long SEQ_MSK_TRANSPOSE = 0x007F0000, transposeShift = 16;

  102. 	static const unsigned long SEQ_MSK_TRANSIGN =  0x00800000;// manually implement sign bit

  103. 	static const unsigned long SEQ_MSK_ROTATE =    0x7F000000, rotateShift = 24;

  104. 	static const unsigned long SEQ_MSK_ROTSIGN =   0x80000000;// manually implement sign bit (+ is right, - is left)

  105. 	

  106. 	inline void init(int length, int runMode) {attributes = ((length) | (((unsigned long)runMode) << runModeShift));}

  107. 	inline void randomize(int maxSteps, int numModes) {attributes = ( (1 + (randomu32() % maxSteps)) | (((unsigned long)(randomu32() % numModes) << runModeShift)) );}

  108. 	

  109. 	inline int getLength() {return (int)(attributes & SEQ_MSK_LENGTH);}

  110. 	inline int getRunMode() {return (int)((attributes & SEQ_MSK_RUNMODE) >> runModeShift);}

  111. 	inline int getTranspose() {

  112. 		int ret = (int)((attributes & SEQ_MSK_TRANSPOSE) >> transposeShift);

  113. 		if ( (attributes & SEQ_MSK_TRANSIGN) != 0)// if negative

  114. 			ret *= -1;

  115. 		return ret;

  116. 	}

  117. 	inline int getRotate() {

  118. 		int ret = (int)((attributes & SEQ_MSK_ROTATE) >> rotateShift);

  119. 		if ( (attributes & SEQ_MSK_ROTSIGN) != 0)// if negative

  120. 			ret *= -1;

  121. 		return ret;

  122. 	}

  123. 	inline unsigned long getSeqAttrib() {return attributes;}

  124. 	

  125. 	inline void setLength(int length) {attributes &= ~SEQ_MSK_LENGTH; attributes |= ((unsigned long)length);}

  126. 	inline void setRunMode(int runMode) {attributes &= ~SEQ_MSK_RUNMODE; attributes |= (((unsigned long)runMode) << runModeShift);}

  127. 	inline void setTranspose(int transp) {

  128. 		attributes &= ~ (SEQ_MSK_TRANSPOSE | SEQ_MSK_TRANSIGN); 

  129. 		attributes |= (((unsigned long)abs(transp)) << transposeShift);

  130. 		if (transp < 0) 

  131. 			attributes |= SEQ_MSK_TRANSIGN;

  132. 	}

  133. 	inline void setRotate(int rotn) {

  134. 		attributes &= ~ (SEQ_MSK_ROTATE | SEQ_MSK_ROTSIGN); 

  135. 		attributes |= (((unsigned long)abs(rotn)) << rotateShift);

  136. 		if (rotn < 0) 

  137. 			attributes |= SEQ_MSK_ROTSIGN;

  138. 	}

  139. 	inline void setSeqAttrib(unsigned long _attributes) {attributes = _attributes;}

  140. };// class SeqAttributes

  141. 

  142. 

  143. //*****************************************************************************

  144. // SequencerKernel

  145. //*****************************************************************************

  146. 

  147. 

  148. struct SeqCPbuffer;

  149. struct SongCPbuffer;

  150. 

  151. class SequencerKernel {

  152. 	public: 

  153. 

  154. 	// Sequencer kernel dimensions

  155. 	static const int MAX_STEPS = 32;// must be a power of two (some multi select loops have bitwise "& (MAX_STEPS - 1)")

  156. 	static const int MAX_SEQS = 64;

  157. 	static const int MAX_PHRASES = 99;// maximum value is 99 (index value is 0 to 98; disp will be 1 to 99)

  158. 

  159. 	// Run modes

  160. 	enum RunModeIds {MODE_FWD, MODE_REV, MODE_PPG, MODE_PEN, MODE_BRN, MODE_RND, MODE_TKA, NUM_MODES};

  161. 	static const std::string modeLabels[NUM_MODES];

  162. 	

  163. 	

  164. 	private:

  165. 	

  166. 	// Gate types

  167. 	static const int NUM_GATES = 12;	

  168. 	static const uint64_t advGateHitMaskLow[NUM_GATES];		

  169. 	static const uint64_t advGateHitMaskHigh[NUM_GATES];

  170. 

  171. 	static constexpr float INIT_CV = 0.0f;

  172. 

  173. 	int id;

  174. 	std::string ids;

  175. 	

  176. 	// Need to save

  177. 	int pulsesPerStep;// stored range is [1:49] so must ALWAYS read thgouth getPulsesPerStep(). Must do this because of knob

  178. 	int delay;

  179. 	int runModeSong;	

  180. 	int songBeginIndex;

  181. 	int songEndIndex;

  182. 	Phrase phrases[MAX_PHRASES];// This is the song (series of phases; a phrase is a sequence number and a repetition value)	

  183. 	SeqAttributes sequences[MAX_SEQS];

  184. 	float cv[MAX_SEQS][MAX_STEPS];// [-3.0 : 3.917].

  185. 	StepAttributes attributes[MAX_SEQS][MAX_STEPS];

  186. 	char dirty[MAX_SEQS];

  187. 	

  188. 	// No need to save

  189. 	int stepIndexRun;

  190. 	unsigned long stepIndexRunHistory;

  191. 	int phraseIndexRun;

  192. 	unsigned long phraseIndexRunHistory;

  193. 	int ppqnCount;

  194. 	int ppqnLeftToSkip;// used in clock delay

  195. 	int gateCode;// -1 = Killed for all pulses of step, 0 = Low for current pulse of step, 1 = High for current pulse of step, 2 = Clk high pulse, 3 = 1ms trig

  196. 	unsigned long slideStepsRemain;// 0 when no slide under way, downward step counter when sliding

  197. 	float slideCVdelta;// no need to initialize, this is only used when slideStepsRemain is not 0

  198. 	SequencerKernel *masterKernel;// nullprt for track 0, used for grouped run modes (tracks B,C,D follow A when random, for example)

  199. 	bool* holdTiedNotesPtr;

  200. 	unsigned long clockPeriod;// counts number of step() calls upward from last clock (reset after clock processed)

  201. 	bool moveStepIndexRunIgnore;

  202. 	

  203. 	

  204. 	public: 

  205. 	

  206. 	void construct(int _id, SequencerKernel *_masterKernel, bool* _holdTiedNotesPtr); // don't want regaular constructor mechanism

  207. 	

  208. 	inline int getRunModeSong() {return runModeSong;}

  209. 	inline int getRunModeSeq(int seqn) {return sequences[seqn].getRunMode();}

  210. 	inline int getBegin() {return songBeginIndex;}

  211. 	inline int getEnd() {return songEndIndex;}

  212. 	inline int getLength(int seqn) {return sequences[seqn].getLength();}

  213. 	inline int getPhraseSeq(int phrn) {return phrases[phrn].getSeqNum();}

  214. 	inline int getPhraseReps(int phrn) {return phrases[phrn].getReps();}

  215. 	inline int getPulsesPerStep() {return (pulsesPerStep > 2 ? ((pulsesPerStep - 1) << 1) : pulsesPerStep);}

  216. 	inline int getDelay() {return delay;}

  217. 	inline int getTransposeOffset(int seqn) {return sequences[seqn].getTranspose();}

  218. 	inline int getRotateOffset(int seqn) {return sequences[seqn].getRotate();}

  219. 	inline int getStepIndexRun() {return stepIndexRun;}

  220. 	inline int getPhraseIndexRun() {return phraseIndexRun;}

  221. 	inline float getCV(int seqn, int stepn) {return cv[seqn][stepn];}

  222. 	inline float getCVRun() {return cv[phrases[phraseIndexRun].getSeqNum()][stepIndexRun];}

  223. 	inline StepAttributes getAttribute(int seqn, int stepn) {return attributes[seqn][stepn];}

  224. 	inline StepAttributes getAttributeRun() {return attributes[phrases[phraseIndexRun].getSeqNum()][stepIndexRun];}

  225. 	inline bool getGate(int seqn, int stepn) {return attributes[seqn][stepn].getGate();}

  226. 	inline bool getGateP(int seqn, int stepn) {return attributes[seqn][stepn].getGateP();}

  227. 	inline bool getSlide(int seqn, int stepn) {return attributes[seqn][stepn].getSlide();}

  228. 	inline bool getTied(int seqn, int stepn) {return attributes[seqn][stepn].getTied();}

  229. 	inline int getGatePVal(int seqn, int stepn) {return attributes[seqn][stepn].getGatePVal();}

  230. 	inline int getSlideVal(int seqn, int stepn) {return attributes[seqn][stepn].getSlideVal();}

  231. 	inline int getVelocityVal(int seqn, int stepn) {return attributes[seqn][stepn].getVelocityVal();}

  232. 	inline int getVelocityValRun() {return getAttributeRun().getVelocityVal();}

  233. 	inline int getGateType(int seqn, int stepn) {return attributes[seqn][stepn].getGateType();}	

  234. 	

  235. 	inline void setPhraseIndexRun(int _phraseIndexRun) {phraseIndexRun = _phraseIndexRun;}

  236. 	inline void setPulsesPerStep(int _pps) {pulsesPerStep = _pps;}

  237. 	inline void setDelay(int _delay) {delay = _delay;}

  238. 	inline void setLength(int seqn, int _length) {sequences[seqn].setLength(_length);}

  239. 	inline void setPhraseReps(int phrn, int _reps) {phrases[phrn].setReps(_reps);}

  240. 	inline void setPhraseSeqNum(int phrn, int _seqn) {phrases[phrn].setSeqNum(_seqn);}

  241. 	inline void setBegin(int phrn) {songBeginIndex = phrn; songEndIndex = max(phrn, songEndIndex);}

  242. 	inline void setEnd(int phrn) {songEndIndex = phrn; songBeginIndex = min(phrn, songBeginIndex);}

  243. 	inline void setRunModeSong(int _runMode) {runModeSong = _runMode;}

  244. 	inline void setRunModeSeq(int seqn, int _runMode) {sequences[seqn].setRunMode(_runMode);}

  245. 	void setGate(int seqn, int stepn, bool newGate, int count);

  246. 	void setGateP(int seqn, int stepn, bool newGateP, int count);

  247. 	void setSlide(int seqn, int stepn, bool newSlide, int count);

  248. 	void setTied(int seqn, int stepn, bool newTied, int count);

  249. 	void setGatePVal(int seqn, int stepn, int gatePval, int count);

  250. 	void setSlideVal(int seqn, int stepn, int slideVal, int count);

  251. 	void setVelocityVal(int seqn, int stepn, int velocity, int count);

  252. 	void setGateType(int seqn, int stepn, int gateType, int count);

  253. 	void setMoveStepIndexRunIgnore() {moveStepIndexRunIgnore = true;}

  254. 	

  255. 	inline int modRunModeSong(int delta) {

  256. 		runModeSong = clamp(runModeSong += delta, 0, NUM_MODES - 1);

  257. 		return runModeSong;

  258. 	}

  259. 	inline int modRunModeSeq(int seqn, int delta) {

  260. 		int rVal = sequences[seqn].getRunMode();

  261. 		rVal = clamp(rVal + delta, 0, NUM_MODES - 1);

  262. 		sequences[seqn].setRunMode(rVal);

  263. 		return rVal;

  264. 	}

  265. 	inline int modLength(int seqn, int delta) {

  266. 		int lVal = sequences[seqn].getLength();

  267. 		lVal = clamp(lVal + delta, 1, MAX_STEPS);

  268. 		sequences[seqn].setLength(lVal);

  269. 		return lVal;

  270. 	}

  271. 	inline int modPhraseSeqNum(int phrn, int delta) {

  272. 		int seqn = phrases[phrn].getSeqNum();

  273. 		seqn = moveIndex(seqn, seqn + delta, MAX_SEQS);

  274. 		phrases[phrn].setSeqNum(seqn);

  275. 		return seqn;

  276. 	}

  277. 	inline int modPhraseReps(int phrn, int delta) {

  278. 		int rVal = phrases[phrn].getReps();

  279. 		rVal = clamp(rVal + delta, 0, 99);

  280. 		phrases[phrn].setReps(rVal);

  281. 		return rVal;

  282. 	}		

  283. 	inline int modPulsesPerStep(int delta) {

  284. 		pulsesPerStep += delta;

  285. 		if (pulsesPerStep < 1) pulsesPerStep = 1;

  286. 		if (pulsesPerStep > 49) pulsesPerStep = 49;

  287. 		return pulsesPerStep;

  288. 	}

  289. 	inline int modDelay(int delta) {

  290. 		delay = clamp(delay + delta, 0, 99);

  291. 		return delay;

  292. 	}

  293. 	inline int modGatePVal(int seqn, int stepn, int delta, int count) {

  294. 		int pVal = getGatePVal(seqn, stepn);

  295. 		pVal = clamp(pVal + delta, 0, 100);

  296. 		setGatePVal(seqn, stepn, pVal, count);

  297. 		return pVal;

  298. 	}		

  299. 	inline int modSlideVal(int seqn, int stepn, int delta, int count) {

  300. 		int sVal = getSlideVal(seqn, stepn);

  301. 		sVal = clamp(sVal + delta, 0, 100);

  302. 		setSlideVal(seqn, stepn, sVal, count);

  303. 		return sVal;

  304. 	}		

  305. 	inline int modVelocityVal(int seqn, int stepn, int delta, int upperLimit, int count) {

  306. 		int vVal = getVelocityVal(seqn, stepn);

  307. 		vVal = clamp(vVal + delta, 0, upperLimit);

  308. 		setVelocityVal(seqn, stepn, vVal, count);

  309. 		return vVal;

  310. 	}		

  311. 	inline void decSlideStepsRemain() {if (slideStepsRemain > 0ul) slideStepsRemain--;}	

  312. 	inline bool toggleGate(int seqn, int stepn, int count) {

  313. 		bool newGate = !attributes[seqn][stepn].getGate();

  314. 		setGate(seqn, stepn, newGate, count);

  315. 		return newGate;

  316. 	}

  317. 	inline bool toggleGateP(int seqn, int stepn, int count) {

  318. 		bool newGateP = !attributes[seqn][stepn].getGateP();

  319. 		setGateP(seqn, stepn, newGateP, count);

  320. 		return newGateP;

  321. 	}

  322. 	inline bool toggleSlide(int seqn, int stepn, int count) {

  323. 		bool newSlide = !attributes[seqn][stepn].getSlide();

  324. 		setSlide(seqn, stepn, newSlide, count);

  325. 		return newSlide;

  326. 	}	

  327. 	inline bool toggleTied(int seqn, int stepn, int count) {

  328. 		bool newTied = !attributes[seqn][stepn].getTied();

  329. 		setTied(seqn, stepn, newTied, count);

  330. 		return newTied;

  331. 	}	

  332. 	float applyNewOctave(int seqn, int stepn, int newOct, int count);

  333. 	float applyNewKey(int seqn, int stepn, int newKeyIndex, int count);

  334. 	void writeCV(int seqn, int stepn, float newCV, int count);

  335. 	

  336. 	inline float calcSlideOffset() {return (slideStepsRemain > 0ul ? (slideCVdelta * (float)slideStepsRemain) : 0.0f);}

  337. 	inline bool calcGate(Trigger clockTrigger, float sampleRate) {

  338. 		if (ppqnLeftToSkip != 0)

  339. 			return false;

  340. 		if (gateCode < 2) 

  341. 			return gateCode == 1;

  342. 		if (gateCode == 2)

  343. 			return clockTrigger.isHigh();

  344. 		return clockPeriod < (unsigned long) (sampleRate * 0.01f);

  345. 	}

  346. 	

  347. 	inline void initPulsesPerStep() {pulsesPerStep = 1;}

  348. 	inline void initDelay() {delay = 0;}

  349. 	

  350. 	void initSequence(int seqn);

  351. 	void initSong();

  352. 	void randomizeSequence(int seqn);

  353. 	void randomizeSong();	

  354. 

  355. 	void copySequence(SeqCPbuffer* seqCPbuf, int seqn, int startCP, int countCP);

  356. 	void pasteSequence(SeqCPbuffer* seqCPbuf, int seqn, int startCP);

  357. 	void copySong(SongCPbuffer* songCPbuf, int startCP, int countCP);

  358. 	void pasteSong(SongCPbuffer* songCPbuf, int startCP);

  359. 	

  360. 	void reset();

  361. 	void randomize(int seqn);

  362. 	void toJson(json_t *rootJ);

  363. 	void fromJson(json_t *rootJ);

  364. 	void initRun();

  365. 	bool clockStep();

  366. 	inline void step() {

  367. 		clockPeriod++;

  368. 	}

  369. 	int keyIndexToGateTypeEx(int keyIndex);

  370. 	void transposeSeq(int seqn, int delta);

  371. 	void unTransposeSeq(int seqn) {

  372. 		transposeSeq(seqn, getTransposeOffset(seqn) * -1);

  373. 	}

  374. 	void rotateSeq(int seqn, int delta);	

  375. 	void unRotateSeq(int seqn) {

  376. 		rotateSeq(seqn, getRotateOffset(seqn) * -1);

  377. 	}

  378. 

  379. 	

  380. 	private:

  381. 	

  382. 	void rotateSeqByOne(int seqn, bool directionRight);

  383. 	inline void propagateCVtoTied(int seqn, int stepn) {

  384. 		for (int i = stepn + 1; i < MAX_STEPS && attributes[seqn][i].getTied(); i++)

  385. 			cv[seqn][i] = cv[seqn][i - 1];	

  386. 	}

  387. 	void activateTiedStep(int seqn, int stepn);

  388. 	void deactivateTiedStep(int seqn, int stepn);

  389. 	void calcGateCodeEx();

  390. 	bool moveStepIndexRun(bool init);

  391. 	void moveSongIndexBackward(bool init, bool rollover);

  392. 	void moveSongIndexForeward(bool init, bool rollover);

  393. 	int tempPhraseIndexes[MAX_PHRASES];// used only in next method	

  394. 	void moveSongIndexRandom(bool init, uint32_t randomValue);	

  395. 	void moveSongIndexBrownian(bool init, uint32_t randomValue);	

  396. 	void movePhraseIndexRun(bool init);

  397. };// class SequencerKernel 

  398. 

  399. 

  400. struct SeqCPbuffer {

  401. 	float cvCPbuffer[SequencerKernel::MAX_STEPS];// copy paste buffer for CVs

  402. 	StepAttributes attribCPbuffer[SequencerKernel::MAX_STEPS];

  403. 	SeqAttributes seqAttribCPbuffer;

  404. 	int storedLength;// number of steps that contain actual cp data

  405. 	

  406. 	SeqCPbuffer() {reset();}

  407. 	void reset();

  408. };// struct SeqCPbuffer

  409. 

  410. 

  411. struct SongCPbuffer {

  412. 	Phrase phraseCPbuffer[SequencerKernel::MAX_PHRASES];

  413. 	int beginIndex;

  414. 	int endIndex;

  415. 	int runModeSong;

  416. 	int storedLength;// number of steps that contain actual cp data

  417. 	

  418. 	SongCPbuffer() {reset();}

  419. 	void reset();

  420. };// song SeqCPbuffer

  421. 

  422. } // namespace rack_plugin_ImpromptuModular

  423. 

  424. #endif