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/mscHack_Control_EnvelopeDat...

474 lines
11KB
Raw Blame History 

  1. #include "mscHack.hpp"

  2. #include "window.hpp"

  3. 

  4. //-----------------------------------------------------

  5. // Procedure:   constructor

  6. //-----------------------------------------------------

  7. void EnvelopeData::Init( int mode, int range, bool bGate, float fsegsize )

  8. {

  9. 	m_bInitialized  = false;

  10. 

  11.     m_Mode = mode;

  12.     m_Range = range;

  13.     m_bGateMode = bGate;

  14.     m_fsegsize = fsegsize;

  15. 

  16. 	for( int hd = 0; hd < ENVELOPE_HANDLES; hd++ )

  17. 		m_HandleVal[ hd ] = 0.5f;

  18. 

  19.     recalcLine( -1 );

  20. 

  21.     setMode( m_Mode );

  22. 

  23.     m_bInitialized  = true;

  24. }

  25. 

  26. //-----------------------------------------------------

  27. // Procedure:   Preset

  28. //-----------------------------------------------------

  29. void EnvelopeData::Preset( int preset )

  30. {

  31.     int i;

  32.     float a, div;

  33. 

  34.     if( preset < 0 || preset >= EnvelopeData::nPRESETS )

  35.     	return;

  36. 

  37.     switch( preset )

  38.     {

  39.     case EnvelopeData::PRESET_CLEAR:

  40.         resetValAll( 0.0f );

  41.         break;

  42.     case EnvelopeData::PRESET_SET:

  43.         resetValAll( 1.0f );

  44.         break;

  45.     case EnvelopeData::PRESET_HALF:

  46.         resetValAll( 0.5f );

  47.         break;

  48.     case EnvelopeData::PRESET_SIN:

  49.         div = (float)(ENVELOPE_HANDLES - 1) / (PI * 2.0f);

  50.         for( i = 0; i < ENVELOPE_HANDLES; i++ )

  51.         {

  52.             a = ( 1.0f + sinf( (float)i / div ) ) / 2.0f;

  53.             setVal( i, a );

  54.         }

  55.         break;

  56.     case EnvelopeData::PRESET_COS:

  57.         div = (float)(ENVELOPE_HANDLES - 1) / (PI * 2.0f);

  58.         for( i = 0; i < ENVELOPE_HANDLES; i++ )

  59.         {

  60.             a = ( 1.0f + cosf( (float)i / div ) ) / 2.0f;

  61.             setVal( i, a );

  62.         }

  63.         break;

  64.     case EnvelopeData::PRESET_COS_HALF:

  65.         div = (float)(ENVELOPE_HANDLES - 1) / (PI * 1.0f);

  66.         for( i = 0; i < ENVELOPE_HANDLES; i++ )

  67.         {

  68.             a = ( 1.0f + cosf( (float)i / div ) ) / 2.0f;

  69.             setVal( i, a );

  70.         }

  71.         break;

  72.     case EnvelopeData::PRESET_TRI_FULL:

  73.         div = 1.0f / 16.0f;

  74.         a = 0;

  75.         for( i = 0; i < ENVELOPE_HANDLES; i++ )

  76.         {

  77.         	setVal( i, a );

  78.             a += div;

  79.         }

  80.         break;

  81.     case EnvelopeData::PRESET_TRI_HALF:

  82.         div = 1.0f / 8.0f;

  83.         a = 0;

  84.         for( i = 0; i < ENVELOPE_HANDLES; i++ )

  85.         {

  86.         	setVal( i, a );

  87.             a += div;

  88. 

  89.             if( i == 8 )

  90.                 a = 0.0f;

  91.         }

  92.         break;

  93.     case EnvelopeData::PRESET_SQR:

  94.         a = 0;

  95.         for( i = 0; i < ENVELOPE_HANDLES; i++ )

  96.         {

  97.         	setVal( i, a );

  98. 

  99.             if( i == 8 )

  100.                 a = 1.0f;

  101.         }

  102.         break;

  103.     default:

  104.         break;

  105.     }

  106. }

  107. 

  108. //-----------------------------------------------------

  109. // Procedure:   getActualVal

  110. //-----------------------------------------------------

  111. float EnvelopeData::getActualVal( float inval )

  112. {

  113.     float val = 0.0f;

  114. 

  115.     switch( m_Range )

  116.     {

  117.     case EnvelopeData_Ranges::RANGE_0to5:

  118.         val = inval * 5.0f;

  119.         break;

  120.     case EnvelopeData_Ranges::RANGE_n5to5:

  121.         val = ( ( inval * 2 ) - 1.0 ) * 5.0f;

  122.         break;

  123.     case EnvelopeData_Ranges::RANGE_0to10:

  124.         val = inval * 10.0f;

  125.         break;

  126.     case EnvelopeData_Ranges::RANGE_n10to10:

  127.         val = ( ( inval * 2 ) - 1.0 ) * 10.0f;

  128.         break;

  129.     case EnvelopeData_Ranges::RANGE_0to1:

  130.     	val = inval;

  131.     	break;

  132.     case EnvelopeData_Ranges::RANGE_n1to1:

  133.     	val = ( ( inval * 2 ) - 1.0 );

  134.     	break;

  135.     case EnvelopeData_Ranges::RANGE_Audio:

  136.     	val = ( ( inval * 2 ) - 1.0 ) * AUDIO_MAX;

  137.     	break;

  138.     }

  139. 

  140.     return val;

  141. }

  142. 

  143. //-----------------------------------------------------

  144. // Function:    line_from_points				

  145. //

  146. //-----------------------------------------------------

  147. void EnvelopeData::line_from_points( float x1, float y1, float x2, float y2, fLine *L )

  148. {

  149.     float m;

  150. 	float xdiff, ydiff;

  151. 

  152.     if( !L )

  153.         return;

  154. 

  155.     memset( L, 0, sizeof( fLine ) );

  156.     L->bSet  = true;

  157. 

  158. 	xdiff = x2 - x1;

  159. 	xdiff = fabs( xdiff );

  160. 

  161. 	ydiff = y2 - y1;

  162. 	ydiff = fabs( ydiff );

  163. 

  164.     // line is vertical

  165.     if( xdiff < 0.000000001 )

  166.     {

  167.         L->fx     = x1;

  168.         L->bVert = true;

  169.         return;

  170.     }

  171. 	else if( ydiff < 0.000000001 )

  172. 	{

  173. 		L->fy     = y1;

  174.         L->bHorz = true;

  175. 		return;

  176. 	}

  177. 

  178. 	//normal line

  179.     m = (y2 - y1) / (x2 - x1);

  180. 

  181.     // point slope form

  182. 	//y = mx + b

  183.     L->fmx = m;

  184.     L->fb  = y1 - (m * x1);

  185. }

  186. 

  187. //-----------------------------------------------------

  188. // Procedure:   valfromline

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

  190. float EnvelopeData::valfromline( int handle, float x )

  191. {

  192.     fLine *L;

  193. 

  194.     if( m_bGateMode )

  195.         return getActualVal( m_HandleVal[ handle ] );

  196. 

  197.     L = &m_Lines[ handle ];

  198. 

  199.     if( L->bHorz )

  200.         return getActualVal( L->fy );

  201. 

  202.     return getActualVal( (x * L->fmx) + L->fb );

  203. }

  204. 

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

  206. // Procedure:   recalcLine

  207. //-----------------------------------------------------

  208. void EnvelopeData::recalcLine( int handle )

  209. {

  210.     float fx1, fx2, fy1, fy2;

  211.     int i;

  212. 

  213.     // calc all lines

  214.     if( handle == -1 )

  215.     {

  216. 		for( int h = 0; h < ENVELOPE_DIVISIONS; h++ )

  217. 		{

  218. 			for( int delta = -1; delta < 1; delta++ )

  219. 			{

  220. 				i = ( h + delta ) & 0xF;

  221. 

  222. 				fx1 = (m_fsegsize * i);

  223. 				fx2 = fx1 + m_fsegsize;

  224. 				fy1 = m_HandleVal[ i ];

  225. 				fy2 = m_HandleVal[ i + 1 ];

  226. 

  227. 				line_from_points( fx1, fy1, fx2, fy2, &m_Lines[ i ] );

  228. 			}

  229. 		}

  230.     }

  231.     // calc line before and line after handle

  232.     else

  233.     {

  234.         for( int delta = -1; delta < 1; delta++ )

  235.         {

  236.             i = ( handle + delta ) & 0xF;

  237. 

  238.             fx1 = (m_fsegsize * i);

  239.             fx2 = fx1 + m_fsegsize;

  240.             fy1 = m_HandleVal[ i ];

  241.             fy2 = m_HandleVal[ i + 1 ];

  242. 

  243.             line_from_points( fx1, fy1, fx2, fy2, &m_Lines[ i ] );

  244.         }

  245.     }

  246. }

  247. 

  248. //-----------------------------------------------------

  249. // Procedure:   resetVal

  250. //-----------------------------------------------------

  251. void EnvelopeData::resetValAll( float val )

  252. {

  253.     if( !m_bInitialized )

  254.         return;

  255. 

  256.     for( int i = 0; i < ENVELOPE_HANDLES; i++ )

  257.     {

  258.         m_HandleVal[ i ] = val;

  259.     }

  260. 

  261.     recalcLine( -1 );

  262. }

  263. 

  264. //-----------------------------------------------------

  265. // Procedure:   setVal

  266. //-----------------------------------------------------

  267. void EnvelopeData::setVal( int handle, float val )

  268. {

  269.     if( !m_bInitialized )

  270.         return;

  271. 

  272.     m_HandleVal[ handle ] = val;

  273.     recalcLine( handle );

  274. }

  275. 

  276. 

  277. //-----------------------------------------------------

  278. // Procedure:   setMode

  279. //-----------------------------------------------------

  280. void EnvelopeData::setMode( int Mode )

  281. {

  282.     if( !m_bInitialized )

  283.         return;

  284. 

  285.     switch( Mode )

  286.     {

  287.     case MODE_LOOP:

  288.         m_Clock.state = STATE_RUN;

  289.         break;

  290.     case MODE_REVERSE:

  291.         m_Clock.state = STATE_RUN_REV;

  292.         break;

  293.     case MODE_ONESHOT:

  294.         m_Clock.fpos = 0;

  295.         m_Clock.state = STATE_WAIT_TRIG;

  296.         break;

  297.     case MODE_TWOSHOT:

  298.         m_Clock.fpos = 0;

  299.         m_Clock.state = STATE_WAIT_TRIG;

  300.         break;

  301.     case MODE_PINGPONG:

  302.         if( m_Clock.state == STATE_WAIT_TRIG )

  303.             m_Clock.state = STATE_RUN;

  304.         else if( m_Clock.state == STATE_WAIT_TRIG_REV )

  305.             m_Clock.state = STATE_RUN_REV;

  306. 

  307.         break;

  308. 

  309.     default:

  310.         return;

  311.     }

  312. 

  313.     m_Clock.prevstate = m_Clock.state;

  314.     m_Mode = Mode;

  315. }

  316. 

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

  318. // Procedure:   setDataAll

  319. //-----------------------------------------------------

  320. void EnvelopeData::setDataAll( int *pint )

  321. {

  322.     int j, count = 0;

  323. 

  324.     if( !m_bInitialized || !pint )

  325.     {

  326.         return;

  327.     }

  328. 

  329. 	for( j = 0; j < ENVELOPE_HANDLES; j++ )

  330. 	{

  331. 		m_HandleVal[ j ] = clamp( (float)pint[ count++ ] / 10000.0f, 0.0f, 1.0f );

  332. 	}

  333. 

  334.     // recalc all lines

  335.     recalcLine( -1 );

  336. }

  337. 

  338. //-----------------------------------------------------

  339. // Procedure:   getDataAll

  340. //-----------------------------------------------------

  341. void EnvelopeData::getDataAll( int *pint )

  342. {

  343.     int j, count = 0;

  344. 

  345.     if( !m_bInitialized || !pint )

  346.     {

  347.         return;

  348.     }

  349. 

  350. 	for( j = 0; j < ENVELOPE_HANDLES; j++ )

  351. 	{

  352. 		pint[ count++ ] = (int)( m_HandleVal[ j ] * 10000.0 );

  353. 	}

  354. }

  355. 

  356. 

  357. //-----------------------------------------------------

  358. // Procedure:   process_state

  359. //-----------------------------------------------------

  360. bool EnvelopeData::process_state( bool bTrig, bool bHold )

  361. {

  362.     switch( m_Clock.state )

  363.     {

  364.     case STATE_RUN:

  365.     case STATE_RUN_REV:

  366. 

  367.         if( bHold )

  368.         {

  369.             m_Clock.prevstate = m_Clock.state;

  370.             m_Clock.state = STATE_HOLD;

  371.             break;

  372.         }

  373.         

  374.         // run reverse

  375.         if( m_Clock.state == STATE_RUN_REV )

  376.         {

  377.             m_Clock.fpos -= m_Clock.syncInc;

  378. 

  379.             if( m_Clock.fpos <= 0.0f )

  380.             {

  381.                 switch( m_Mode )

  382.                 {

  383.                 case MODE_TWOSHOT:

  384.                     m_Clock.fpos = 0;

  385.                     m_Clock.state = STATE_WAIT_TRIG;

  386.                     break;

  387. 

  388.                 case MODE_PINGPONG:

  389.                     m_Clock.fpos = -m_Clock.fpos;

  390.                     m_Clock.state = STATE_RUN;

  391.                     break;

  392. 

  393.                 case MODE_REVERSE:

  394.                 default:

  395.                     m_Clock.fpos += engineGetSampleRate();

  396.                 }

  397.             }

  398.         }

  399.         // run forward

  400.         else

  401.         {

  402.             m_Clock.fpos += m_Clock.syncInc;

  403. 

  404.             if( m_Clock.fpos >= engineGetSampleRate() )

  405.             {

  406.                 switch( m_Mode )

  407.                 {

  408.                 case MODE_ONESHOT:

  409.                     m_Clock.fpos = engineGetSampleRate() - 1.0f;;

  410.                     m_Clock.state = STATE_WAIT_TRIG;

  411.                     break;

  412.                 case MODE_TWOSHOT:

  413.                     m_Clock.fpos = engineGetSampleRate() - 1.0f;

  414.                     m_Clock.state = STATE_WAIT_TRIG_REV;

  415.                     break;

  416.                 case MODE_PINGPONG:

  417.                     m_Clock.fpos -= (m_Clock.fpos - engineGetSampleRate()) * 2.0f;

  418.                     m_Clock.state = STATE_RUN_REV;

  419.                     break;

  420.                 case MODE_LOOP:

  421.                 default:

  422.                     m_Clock.fpos -= engineGetSampleRate();

  423.                 }

  424.             }

  425.         }

  426. 

  427.         break;

  428. 

  429.     case STATE_WAIT_TRIG:

  430.         if( bTrig )

  431.         {

  432.             m_Clock.fpos = 0;

  433.             m_Clock.state = STATE_RUN;

  434.         }

  435.         break;

  436.     case STATE_WAIT_TRIG_REV:

  437.         if( bTrig )

  438.         {

  439.             m_Clock.fpos = engineGetSampleRate();

  440.             m_Clock.state = STATE_RUN_REV;

  441.         }

  442.         break;

  443. 

  444.     case STATE_HOLD:

  445.         if( !bHold )

  446.         {

  447.             m_Clock.state = m_Clock.prevstate;

  448.             break;

  449.         }

  450.         break;

  451.     }

  452. 

  453.     return true;

  454. }

  455. 

  456. //-----------------------------------------------------

  457. // Procedure:   procStep

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

  459. float EnvelopeData::procStep( bool bTrig, bool bHold )

  460. {

  461.     int handle;

  462. 

  463.     if( !m_bInitialized )

  464.     	return 0.0f;

  465. 

  466.     process_state( bTrig, bHold );

  467. 

  468.     m_fIndicator = m_Clock.fpos / engineGetSampleRate();

  469. 

  470.     handle = (int)( m_Clock.fpos / ( engineGetSampleRate() / (float)ENVELOPE_DIVISIONS ) );

  471. 

  472.     return valfromline( handle, m_fIndicator * m_fsegsize * (float)ENVELOPE_DIVISIONS );

  473. }