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.
1796 Commits
16 Branches
14GB
Tree: 9dfcdf7d66
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9dfcdf7d66'
${ noResults }
Carla/source/modules/native-plugins/projectm.cpp

425 lines
11KB
Raw Blame History 

  1. /*

  2.  * Carla Native Plugins

  3.  * Copyright (C) 2012-2014 Filipe Coelho <falktx@falktx.com>

  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 "CarlaNative.hpp"

  19. #include "CarlaMutex.hpp"

  20. 

  21. #include "dgl/StandaloneWindow.hpp"

  22. #include "dgl/Widget.hpp"

  23. 

  24. #include "libprojectM/projectM.hpp"

  25. 

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

  27. 

  28. static const projectM::Settings kSettings = {

  29.     /* meshX        */ 32,

  30.     /* meshY        */ 24,

  31.     /* fps          */ 35,

  32.     /* textureSize  */ 1024,

  33.     /* windowWidth  */ 512,

  34.     /* windowHeight */ 512,

  35.     /* presetURL    */ "/usr/share/projectM/presets",

  36.     /* titleFontURL */ "/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans.ttf",

  37.     /* menuFontURL  */ "/usr/share/fonts/truetype/ttf-dejavu/DejaVuSansMono.ttf",

  38.     /* smoothPresetDuration  */ 5,

  39.     /* presetDuration        */ 30,

  40.     /* beatSensitivity       */ 10.0f,

  41.     /* aspectCorrection      */ true,

  42.     /* easterEgg             */ 1.0f,

  43.     /* shuffleEnabled        */ true,

  44.     /* softCutRatingsEnabled */ false

  45. };

  46. 

  47. // -----------------------------------------------------------------------

  48. 

  49. class ProjectMWidget : public DGL::Widget

  50. {

  51. public:

  52.     ProjectMWidget(DGL::Window& parent)

  53.         : DGL::Widget(parent),

  54.           pm(nullptr)

  55.     {

  56.     }

  57. 

  58.     ~ProjectMWidget()

  59.     {

  60.         if (pm == nullptr)

  61.             return;

  62. 

  63.         delete pm;

  64.         pm = nullptr;

  65.     }

  66. 

  67.     projectM* getPM() noexcept

  68.     {

  69.         return pm;

  70.     }

  71. 

  72. protected:

  73.     void onDisplay() override

  74.     {

  75.         if (pm == nullptr)

  76.             return;

  77. 

  78.         pm->renderFrame();

  79.     }

  80. 

  81.     void onClose() override

  82.     {

  83.     }

  84. 

  85.     bool onKeyboard(const bool press, const uint32_t key) override

  86.     {

  87.         if (pm == nullptr)

  88.             return false;

  89. 

  90.         projectMKeycode  pmKey = PROJECTM_K_NONE;

  91.         projectMModifier pmMod = PROJECTM_KMOD_LSHIFT;

  92. 

  93.         if ((key >= PROJECTM_K_0 && key <= PROJECTM_K_9) ||

  94.             (key >= PROJECTM_K_A && key <= PROJECTM_K_Z) ||

  95.             (key >= PROJECTM_K_a && key <= PROJECTM_K_z))

  96.         {

  97.             pmKey = static_cast<projectMKeycode>(key);

  98.         }

  99.         else

  100.         {

  101.             switch (key)

  102.             {

  103.             case DGL::CHAR_BACKSPACE:

  104.                 pmKey = PROJECTM_K_BACKSPACE;

  105.                 break;

  106.             case DGL::CHAR_ESCAPE:

  107.                 pmKey = PROJECTM_K_ESCAPE;

  108.                 break;

  109.             case DGL::CHAR_DELETE:

  110.                 pmKey = PROJECTM_K_DELETE;

  111.                 break;

  112.             }

  113.         }

  114. 

  115.         if (pmKey == PROJECTM_K_NONE)

  116.             return false;

  117. 

  118.         if (const int mod = getModifiers())

  119.         {

  120.             if (mod & DGL::MODIFIER_CTRL)

  121.                 pmMod = PROJECTM_KMOD_LCTRL;

  122.         }

  123. 

  124.         pm->key_handler(press ? PROJECTM_KEYUP : PROJECTM_KEYDOWN, pmKey, pmMod);

  125. 

  126.         return true;

  127.     }

  128. 

  129.     bool onSpecial(const bool press, const DGL::Key key) override

  130.     {

  131.         if (pm == nullptr)

  132.             return false;

  133. 

  134.         projectMKeycode  pmKey = PROJECTM_K_NONE;

  135.         projectMModifier pmMod = PROJECTM_KMOD_LSHIFT;

  136. 

  137.         switch (key)

  138.         {

  139.         case DGL::KEY_F1:

  140.             pmKey = PROJECTM_K_F1;

  141.             break;

  142.         case DGL::KEY_F2:

  143.             pmKey = PROJECTM_K_F2;

  144.             break;

  145.         case DGL::KEY_F3:

  146.             pmKey = PROJECTM_K_F3;

  147.             break;

  148.         case DGL::KEY_F4:

  149.             pmKey = PROJECTM_K_F4;

  150.             break;

  151.         case DGL::KEY_F5:

  152.             pmKey = PROJECTM_K_F5;

  153.             break;

  154.         case DGL::KEY_F6:

  155.             pmKey = PROJECTM_K_F6;

  156.             break;

  157.         case DGL::KEY_F7:

  158.             pmKey = PROJECTM_K_F7;

  159.             break;

  160.         case DGL::KEY_F8:

  161.             pmKey = PROJECTM_K_F8;

  162.             break;

  163.         case DGL::KEY_F9:

  164.             pmKey = PROJECTM_K_F9;

  165.             break;

  166.         case DGL::KEY_F10:

  167.             pmKey = PROJECTM_K_F10;

  168.             break;

  169.         case DGL::KEY_F11:

  170.             pmKey = PROJECTM_K_F11;

  171.             break;

  172.         case DGL::KEY_F12:

  173.             pmKey = PROJECTM_K_F12;

  174.             break;

  175.         case DGL::KEY_LEFT:

  176.             pmKey = PROJECTM_K_LEFT;

  177.             break;

  178.         case DGL::KEY_UP:

  179.             pmKey = PROJECTM_K_UP;

  180.             break;

  181.         case DGL::KEY_RIGHT:

  182.             pmKey = PROJECTM_K_RIGHT;

  183.             break;

  184.         case DGL::KEY_DOWN:

  185.             pmKey = PROJECTM_K_DOWN;

  186.             break;

  187.         case DGL::KEY_PAGE_UP:

  188.             pmKey = PROJECTM_K_PAGEUP;

  189.             break;

  190.         case DGL::KEY_PAGE_DOWN:

  191.             pmKey = PROJECTM_K_PAGEDOWN;

  192.             break;

  193.         case DGL::KEY_HOME:

  194.             pmKey = PROJECTM_K_HOME;

  195.             break;

  196.         case DGL::KEY_END:

  197.             pmKey = PROJECTM_K_END;

  198.             break;

  199.         case DGL::KEY_INSERT:

  200.             pmKey = PROJECTM_K_INSERT;

  201.             break;

  202.         case DGL::KEY_SHIFT:

  203.             pmKey = PROJECTM_K_LSHIFT;

  204.             break;

  205.         case DGL::KEY_CTRL:

  206.             pmKey = PROJECTM_K_LCTRL;

  207.             break;

  208.         case DGL::KEY_ALT:

  209.         case DGL::KEY_SUPER:

  210.             break;

  211.         }

  212. 

  213.         if (pmKey == PROJECTM_K_NONE)

  214.             return false;

  215. 

  216.         if (const int mod = getModifiers())

  217.         {

  218.             if (mod & DGL::MODIFIER_CTRL)

  219.                 pmMod = PROJECTM_KMOD_LCTRL;

  220.         }

  221. 

  222.         pm->key_handler(press ? PROJECTM_KEYUP : PROJECTM_KEYDOWN, pmKey, pmMod);

  223. 

  224.         return true;

  225.     }

  226. 

  227.     void onReshape(const int width, const int height) override

  228.     {

  229.         /* Our shading model--Gouraud (smooth). */

  230.         glShadeModel(GL_SMOOTH);

  231. 

  232.         /* Set the clear color. */

  233.         glClearColor(0, 0, 0, 0);

  234.         /* Setup our viewport. */

  235.         glViewport(0, 0, width, height);

  236. 

  237.         /*

  238.         * Change to the projection matrix and set

  239.         * our viewing volume.

  240.         */

  241.         glMatrixMode(GL_TEXTURE);

  242.         glLoadIdentity();

  243. 

  244.         //gluOrtho2D(0.0, (GLfloat) width, 0.0, (GLfloat) height);

  245.         //glOrtho(0, width, height, 0, 0.0f, 1.0f);

  246.         glMatrixMode(GL_PROJECTION);

  247.         glLoadIdentity();

  248. 

  249.         glMatrixMode(GL_MODELVIEW);

  250.         glLoadIdentity();

  251. 

  252.         glDrawBuffer(GL_BACK);

  253.         glReadBuffer(GL_BACK);

  254.         glEnable(GL_BLEND);

  255. 

  256.         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

  257.         glEnable(GL_LINE_SMOOTH);

  258.         glEnable(GL_POINT_SMOOTH);

  259.         glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

  260.         glClear(GL_COLOR_BUFFER_BIT);

  261. 

  262.         glLineStipple(2, 0xAAAA);

  263. 

  264.         if (pm == nullptr)

  265.             pm = new projectM(kSettings); // std::string("/usr/share/projectM/config.inp"));

  266. 

  267.         pm->projectM_resetGL(width, height);

  268.     }

  269. 

  270. private:

  271.     projectM* pm;

  272. 

  273.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(ProjectMWidget)

  274. };

  275. 

  276. // -----------------------------------------------------------------------

  277. 

  278. class ProjectMUI : public DGL::StandaloneWindow

  279. {

  280. public:

  281.     ProjectMUI(const NativeHostDescriptor* const host)

  282.         : DGL::StandaloneWindow(),

  283.           fWidget(getWindow())

  284.     {

  285.         fWindow.setSize(kSettings.windowWidth, kSettings.windowHeight);

  286.         fWindow.setTitle(host->uiName);

  287. 

  288.         if (host->uiParentId != 0)

  289.             fWindow.setTransientWinId(host->uiParentId);

  290. 

  291.         fWindow.show();

  292.     }

  293. 

  294.     projectM* getPM() noexcept

  295.     {

  296.         return fWidget.getPM();

  297.     }

  298. 

  299.     void idle()

  300.     {

  301.         fApp.idle();

  302.         fWindow.repaint();

  303.     }

  304. 

  305.     void focus()

  306.     {

  307.         fWindow.focus();

  308.     }

  309. 

  310. private:

  311.     ProjectMWidget fWidget;

  312. 

  313.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(ProjectMUI)

  314. };

  315. 

  316. // -----------------------------------------------------------------------

  317. 

  318. class ProjectMPlugin : public NativePluginClass

  319. {

  320. public:

  321.     ProjectMPlugin(const NativeHostDescriptor* const host)

  322.         : NativePluginClass(host),

  323.           fPM(nullptr),

  324.           fUI(nullptr)

  325.     {

  326.     }

  327. 

  328.     ~ProjectMPlugin() override

  329.     {

  330.         CARLA_SAFE_ASSERT(fUI == nullptr);

  331.     }

  332. 

  333. protected:

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

  335.     // Plugin process calls

  336. 

  337.     void process(float** ins, float**, const uint32_t frames, const NativeMidiEvent* const, const uint32_t) override

  338.     {

  339.         const CarlaMutexLocker csm(fMutex);

  340. 

  341.         if (fPM == nullptr)

  342.             return;

  343. 

  344.         fPM->pcm()->addPCMfloat(ins[0] ,frames);

  345.     }

  346. 

  347.     // -------------------------------------------------------------------

  348.     // Plugin UI calls

  349. 

  350.     void uiShow(const bool show) override

  351.     {

  352.         if (show)

  353.         {

  354.             if (fUI == nullptr)

  355.                 fUI = new ProjectMUI(getHostHandle());

  356. 

  357.             fUI->focus();

  358.         }

  359.         else if (fUI != nullptr)

  360.         {

  361.             {

  362.                 const CarlaMutexLocker csm(fMutex);

  363.                 fPM = nullptr;

  364.             }

  365. 

  366.             delete fUI;

  367.             fUI = nullptr;

  368.         }

  369.     }

  370. 

  371.     void uiIdle() override

  372.     {

  373.         if (fUI == nullptr)

  374.             return;

  375. 

  376.         fUI->idle();

  377. 

  378.         if (fPM != nullptr)

  379.             return;

  380. 

  381.         const CarlaMutexLocker csm(fMutex);

  382.         fPM = fUI->getPM();

  383.         CARLA_SAFE_ASSERT(fPM != nullptr);

  384.     }

  385. 

  386. private:

  387.     projectM*   fPM;

  388.     ProjectMUI* fUI;

  389. 

  390.     // need to ensure pm is valid

  391.     CarlaMutex fMutex;

  392. 

  393.     PluginClassEND(ProjectMPlugin)

  394.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(ProjectMPlugin)

  395. };

  396. 

  397. // -----------------------------------------------------------------------

  398. 

  399. static const NativePluginDescriptor projectmDesc = {

  400.     /* category  */ PLUGIN_CATEGORY_UTILITY,

  401.     /* hints     */ static_cast<NativePluginHints>(/*PLUGIN_IS_RTSAFE|*/PLUGIN_HAS_UI|PLUGIN_USES_PARENT_ID),

  402.     /* supports  */ static_cast<NativePluginSupports>(0x0),

  403.     /* audioIns  */ 1,

  404.     /* audioOuts */ 0,

  405.     /* midiIns   */ 0,

  406.     /* midiOuts  */ 0,

  407.     /* paramIns  */ 0,

  408.     /* paramOuts */ 0,

  409.     /* name      */ "ProjectM",

  410.     /* label     */ "projectm",

  411.     /* maker     */ "falkTX",

  412.     /* copyright */ "GNU GPL v2+",

  413.     PluginDescriptorFILL(ProjectMPlugin)

  414. };

  415. 

  416. // -----------------------------------------------------------------------

  417. 

  418. CARLA_EXPORT

  419. void carla_register_native_plugin_projectm()

  420. {

  421.     carla_register_native_plugin(&projectmDesc);

  422. }

  423. 

  424. // -----------------------------------------------------------------------