falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
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.
1769 Commits
16 Branches
270MB
Tree: c8a3e421f9
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c8a3e421f9'
${ noResults }
Carla/source/modules/native-plugins/vectorjuice/VectorJuicePlugin.cpp

412 lines
11KB
Raw Blame History 

  1. /*

  2.  * Vector Juice Plugin

  3.  * Copyright (C) 2014 Andre Sklenar <andre.sklenar@gmail.com>, www.juicelab.cz

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the doc/GPL.txt file.

  16.  */

  17. 

  18. #include "VectorJuicePlugin.hpp"

  19. 

  20. 

  21. 

  22. START_NAMESPACE_DISTRHO

  23. 

  24. // -----------------------------------------------------------------------

  25. 

  26. VectorJuicePlugin::VectorJuicePlugin()

  27.     : Plugin(paramCount, 1, 0) // 1 program, 0 states

  28. {

  29.     // set default values

  30.     d_setProgram(0);

  31. 

  32.     // reset

  33.     d_deactivate();

  34. }

  35. 

  36. // -----------------------------------------------------------------------

  37. // Init

  38. 

  39. void VectorJuicePlugin::d_initParameter(uint32_t index, Parameter& parameter)

  40. {

  41.     switch (index)

  42.     {

  43.     case paramX:

  44.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  45.         parameter.name       = "X";

  46.         parameter.symbol     = "x";

  47.         parameter.unit       = "";

  48.         parameter.ranges.def = 0.5f;

  49.         parameter.ranges.min = 0.0f;

  50.         parameter.ranges.max = 1.0f;

  51.         break;

  52. 

  53.     case paramY:

  54.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  55.         parameter.name       = "Y";

  56.         parameter.symbol     = "y";

  57.         parameter.unit       = "";

  58.         parameter.ranges.def = 0.5f;

  59.         parameter.ranges.min = 0.0f;

  60.         parameter.ranges.max = 1.0f;

  61.         break;

  62. 

  63.     case paramOrbitSpeedX:

  64.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  65.         parameter.name       = "Orbit Speed X";

  66.         parameter.symbol     = "";

  67.         parameter.unit       = "";

  68.         parameter.ranges.def = 4.0f;

  69.         parameter.ranges.min = 1.0f;

  70.         parameter.ranges.max = 128.0f;

  71.         break;

  72. 

  73.     case paramOrbitSpeedY:

  74.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  75.         parameter.name       = "Orbit Speed Y";

  76.         parameter.symbol     = "";

  77.         parameter.unit       = "";

  78.         parameter.ranges.def = 4.0f;

  79.         parameter.ranges.min = 1.0f;

  80.         parameter.ranges.max = 128.0f;

  81.         break;

  82. 

  83.     case paramOrbitSizeX:

  84.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  85.         parameter.name       = "Orbit Size X";

  86.         parameter.symbol     = "osl";

  87.         parameter.unit       = "";

  88.         parameter.ranges.def = 0.5f;

  89.         parameter.ranges.min = 0.0f;

  90.         parameter.ranges.max = 1.0f;

  91.         break;

  92. 

  93.     case paramOrbitSizeY:

  94.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  95.         parameter.name       = "Orbit Size Y";

  96.         parameter.symbol     = "osr";

  97.         parameter.unit       = "";

  98.         parameter.ranges.def = 0.5f;

  99.         parameter.ranges.min = 0.0f;

  100.         parameter.ranges.max = 1.0f;

  101.         break;

  102. 

  103.     case paramSubOrbitSpeed:

  104.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  105.         parameter.name       = "SubOrbit Speed";

  106.         parameter.symbol     = "";

  107.         parameter.unit       = "";

  108.         parameter.ranges.def = 32.0f;

  109.         parameter.ranges.min = 1.0f;

  110.         parameter.ranges.max = 128.0f;

  111.         break;

  112. 

  113.     case paramSubOrbitSize:

  114.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  115.         parameter.name       = "SubOrbit Size";

  116.         parameter.symbol     = "";

  117.         parameter.unit       = "";

  118.         parameter.ranges.def = 0.5f;

  119.         parameter.ranges.min = 0.0f;

  120.         parameter.ranges.max = 1.0f;

  121.         break;

  122. 

  123.     case paramSubOrbitSmooth:

  124.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  125.         parameter.name       = "SubOrbit Wave";

  126.         parameter.symbol     = "";

  127.         parameter.unit       = "";

  128.         parameter.ranges.def = 0.5f;

  129.         parameter.ranges.min = 0.0f;

  130.         parameter.ranges.max = 1.0f;

  131.         break;

  132. 

  133.     case paramOrbitWaveX:

  134.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  135.         parameter.name       = "Orbit Wave X";

  136.         parameter.symbol     = "";

  137.         parameter.unit       = "";

  138.         parameter.ranges.def = 3.0f;

  139.         parameter.ranges.min = 1.0f;

  140.         parameter.ranges.max = 4.0f;

  141.         break;

  142. 

  143.     case paramOrbitPhaseX:

  144.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  145.         parameter.name       = "Orbit Phase X";

  146.         parameter.symbol     = "";

  147.         parameter.unit       = "";

  148.         parameter.ranges.def = 0.0f;

  149.         parameter.ranges.min = 0.0f;

  150.         parameter.ranges.max = 1.0f;

  151.         break;

  152. 

  153.     case paramOrbitPhaseY:

  154.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  155.         parameter.name       = "Orbit Phase Y";

  156.         parameter.symbol     = "";

  157.         parameter.unit       = "";

  158.         parameter.ranges.def = 0.0f;

  159.         parameter.ranges.min = 0.0f;

  160.         parameter.ranges.max = 1.0f;

  161.         break;

  162. 

  163.     case paramOrbitWaveY:

  164.         parameter.hints      = PARAMETER_IS_AUTOMABLE;

  165.         parameter.name       = "Orbit Wave Y";

  166.         parameter.symbol     = "";

  167.         parameter.unit       = "";

  168.         parameter.ranges.def = 3.0f;

  169.         parameter.ranges.min = 1.0f;

  170.         parameter.ranges.max = 4.0f;

  171.         break;

  172. 

  173.     case paramOrbitOutX:

  174.         parameter.hints      = PARAMETER_IS_OUTPUT;

  175.         parameter.name       = "Orbit X";

  176.         parameter.symbol     = "orx";

  177.         parameter.unit       = "";

  178.         parameter.ranges.def = 0.5f;

  179.         parameter.ranges.min = 0.0f;

  180.         parameter.ranges.max = 1.0f;

  181.         break;

  182. 

  183.     case paramOrbitOutY:

  184.         parameter.hints      = PARAMETER_IS_OUTPUT;

  185.         parameter.name       = "Orbit Y";

  186.         parameter.symbol     = "ory";

  187.         parameter.unit       = "";

  188.         parameter.ranges.def = 0.5f;

  189.         parameter.ranges.min = 0.0f;

  190.         parameter.ranges.max = 1.0f;

  191.         break;

  192. 

  193.     case paramSubOrbitOutX:

  194.         parameter.hints      = PARAMETER_IS_OUTPUT;

  195.         parameter.name       = "SubOrbit X";

  196.         parameter.symbol     = "sorx";

  197.         parameter.unit       = "";

  198.         parameter.ranges.def = 0.5f;

  199.         parameter.ranges.min = 0.0f;

  200.         parameter.ranges.max = 1.0f;

  201.         break;

  202. 

  203.     case paramSubOrbitOutY:

  204.         parameter.hints      = PARAMETER_IS_OUTPUT;

  205.         parameter.name       = "SubOrbit Y";

  206.         parameter.symbol     = "sory";

  207.         parameter.unit       = "";

  208.         parameter.ranges.def = 0.5f;

  209.         parameter.ranges.min = 0.0f;

  210.         parameter.ranges.max = 1.0f;

  211.         break;

  212.     }

  213. }

  214. 

  215. void VectorJuicePlugin::d_initProgramName(uint32_t index, d_string& programName)

  216. {

  217.     if (index != 0)

  218.         return;

  219. 

  220.     programName = "Default";

  221. }

  222. 

  223. // -----------------------------------------------------------------------

  224. // Internal data

  225. 

  226. float VectorJuicePlugin::d_getParameterValue(uint32_t index) const

  227. {

  228.     switch (index)

  229.     {

  230.     case paramX:

  231.         return x;

  232.     case paramY:

  233.         return y;

  234.     case paramOrbitSizeX:

  235.         return orbitSizeX;

  236.     case paramOrbitSizeY:

  237.         return orbitSizeY;

  238.     case paramOrbitSpeedX:

  239.         return orbitSpeedX;

  240.     case paramOrbitSpeedY:

  241.         return orbitSpeedY;

  242.     case paramSubOrbitSpeed:

  243.         return subOrbitSpeed;

  244.     case paramSubOrbitSize:

  245.         return subOrbitSize;

  246.     case paramOrbitOutX:

  247.         return orbitX;

  248.     case paramOrbitOutY:

  249.         return orbitY;

  250.     case paramSubOrbitOutX:

  251.         return subOrbitX;

  252.     case paramSubOrbitOutY:

  253.         return subOrbitY;

  254.     case paramSubOrbitSmooth:

  255.         return subOrbitSmooth;

  256.     case paramOrbitWaveX:

  257.         return orbitWaveX;

  258.     case paramOrbitWaveY:

  259.         return orbitWaveY;

  260.     case paramOrbitPhaseX:

  261.         return orbitPhaseY;

  262.     case paramOrbitPhaseY:

  263.         return orbitPhaseY;

  264.     default:

  265.         return 0.0f;

  266.     }

  267. }

  268. 

  269. void VectorJuicePlugin::d_setParameterValue(uint32_t index, float value)

  270. {

  271.     switch (index)

  272.     {

  273.     case paramX:

  274.         x = value;

  275.         break;

  276.     case paramY:

  277.         y = value;

  278.         break;

  279.     case paramOrbitSpeedX:

  280.         orbitSpeedX = value;

  281.         resetPhase();

  282.         break;

  283.     case paramOrbitSpeedY:

  284.         orbitSpeedY = value;

  285.         resetPhase();

  286.         break;

  287.     case paramOrbitSizeX:

  288.         orbitSizeX = value;

  289.         break;

  290.     case paramOrbitSizeY:

  291.         orbitSizeY = value;

  292.         break;

  293.     case paramSubOrbitSpeed:

  294.         subOrbitSpeed = value;

  295.         resetPhase();

  296.         break;

  297.     case paramSubOrbitSize:

  298.         subOrbitSize = value;

  299.         break;

  300.     case paramSubOrbitSmooth:

  301.         subOrbitSmooth = value;

  302.         break;

  303.     case paramOrbitWaveX:

  304.         orbitWaveX = value;

  305.         break;

  306.     case paramOrbitWaveY:

  307.         orbitWaveY = value;

  308.         break;

  309.     case paramOrbitPhaseX:

  310.         orbitPhaseX = value;

  311.         resetPhase();

  312.         break;

  313.     case paramOrbitPhaseY:

  314.         orbitPhaseY = value;

  315.         resetPhase();

  316.         break;

  317.     }

  318. }

  319. 

  320. void VectorJuicePlugin::d_setProgram(uint32_t index)

  321. {

  322.     if (index != 0)

  323.         return;

  324. 

  325.     /* Default parameter values */

  326.     x = 0.5f;

  327.     y = 0.5f;

  328.     orbitSpeedX = 4.0f;

  329.     orbitSpeedY = 4.0f;

  330.     orbitSizeX = 0.5f;

  331.     orbitSizeY = 0.5f;

  332.     subOrbitSize = 0.5f;

  333.     subOrbitSpeed = 32.0f;

  334.     orbitWaveX = 3.0f;

  335.     orbitWaveY = 3.0f;

  336.     subOrbitSmooth = 0.5f;

  337.     orbitPhaseX = 0.0f;

  338.     orbitPhaseY = 0.0f;

  339. 

  340.     /* Default variable values */

  341.     orbitX=orbitY=orbitTX=orbitTY=0.5;

  342.     subOrbitX=subOrbitY=subOrbitTX=subOrbitTY=0;

  343.     interpolationDivider=200;

  344.     bar=tickX=tickY=percentageX=percentageY=tickOffsetX=0;

  345.     tickOffsetY=sinePosX=sinePosY=tick=percentage=tickOffset=sinePos=0;

  346.     waveBlend=0;

  347. 

  348.     //parameter smoothing

  349.     for (int i=0; i<2; i++) {

  350.         sA[i] = 0.99f;

  351.         sB[i] = 1.f - sA[i];

  352.         sZ[i] = 0;

  353.     }

  354. 

  355.     /* reset filter values */

  356.     d_activate();

  357. }

  358. 

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

  360. // Process

  361. 

  362. void VectorJuicePlugin::d_activate()

  363. {

  364.     //sinePos = 0;

  365. }

  366. 

  367. void VectorJuicePlugin::d_deactivate()

  368. {

  369.     // all values to zero

  370. }

  371. 

  372. void VectorJuicePlugin::d_run(float** inputs, float** outputs, uint32_t frames)

  373. {

  374.     float out1, out2, tX, tY;

  375. 

  376.     for (uint32_t i=0; i<frames; i++) {

  377.         //1.41421 -> 1

  378.         //<0 = 0

  379. 

  380.         animate();

  381. 

  382.         tX = subOrbitX;

  383.         tY = subOrbitY;

  384. 

  385.         out1 = inputs[0][i]*tN(1-std::sqrt((tX*tX)+(tY*tY)));

  386.         out2 = inputs[1][i]*tN(1-std::sqrt((tX*tX)+(tY*tY)));

  387. 

  388.         out1 += inputs[2][i]*tN(1-std::sqrt(((1-tX)*(1-tX))+(tY*tY)));

  389.         out2 += inputs[3][i]*tN(1-std::sqrt(((1-tX)*(1-tX))+(tY*tY)));

  390. 

  391.         out1 += inputs[4][i]*tN(1-std::sqrt(((1-tX)*(1-tX))+((1-tY)*(1-tY))));

  392.         out2 += inputs[5][i]*tN(1-std::sqrt(((1-tX)*(1-tX))+((1-tY)*(1-tY))));

  393. 

  394.         out1 += inputs[6][i]*tN(1-std::sqrt((tX*tX)+((1-tY)*(1-tY))));

  395.         out2 += inputs[7][i]*tN(1-std::sqrt((tX*tX)+((1-tY)*(1-tY))));

  396. 

  397.         outputs[0][i] = out1;

  398.         outputs[1][i] = out2;

  399.     }

  400. }

  401. 

  402. // -----------------------------------------------------------------------

  403. 

  404. Plugin* createPlugin()

  405. {

  406.     return new VectorJuicePlugin();

  407. }

  408. 

  409. // -----------------------------------------------------------------------

  410. 

  411. END_NAMESPACE_DISTRHO