124 lines
4.0 KiB
C++
124 lines
4.0 KiB
C++
/*
|
|
* DISTRHO Cardinal Plugin
|
|
* Copyright (C) 2021 Filipe Coelho <falktx@falktx.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 3 of
|
|
* the License, or any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* For a full copy of the GNU General Public License see the LICENSE file.
|
|
*/
|
|
|
|
#include <rack.hpp>
|
|
#include <context.hpp>
|
|
|
|
#include "DistrhoUtils.hpp"
|
|
|
|
using namespace rack;
|
|
|
|
extern Model* modelSpringReverb;
|
|
Plugin* pluginInstance__Befaco;
|
|
|
|
namespace rack {
|
|
Context::~Context() {
|
|
}
|
|
static thread_local Context* threadContext;
|
|
Context* contextGet() {
|
|
DISTRHO_SAFE_ASSERT(threadContext != nullptr);
|
|
return threadContext;
|
|
}
|
|
// Apple's clang incorrectly compiles this function when -O2 or higher is enabled.
|
|
#ifdef ARCH_MAC
|
|
__attribute__((optnone))
|
|
#endif
|
|
void contextSet(Context* const context) {
|
|
// DISTRHO_SAFE_ASSERT(threadContext == nullptr);
|
|
threadContext = context;
|
|
}
|
|
Exception::Exception(const char* format, ...)
|
|
{
|
|
va_list args;
|
|
va_start(args, format);
|
|
msg = string::fV(format, args);
|
|
va_end(args);
|
|
}
|
|
namespace asset {
|
|
std::string plugin(plugin::Plugin* plugin, std::string filename) { return {}; }
|
|
std::string system(std::string filename) { return {}; }
|
|
}
|
|
namespace engine {
|
|
float Engine::getParamValue(Module* module, int paramId) { return 0.0f; }
|
|
float Engine::getParamSmoothValue(Module* module, int paramId) { return 0.0f; }
|
|
void Engine::setParamValue(Module* module, int paramId, float value) {}
|
|
void Engine::setParamSmoothValue(Module* module, int paramId, float value) {}
|
|
}
|
|
namespace plugin {
|
|
void Plugin::addModel(Model* model)
|
|
{
|
|
// Check that the model is not added to a plugin already
|
|
DISTRHO_SAFE_ASSERT_RETURN(model != nullptr,);
|
|
DISTRHO_SAFE_ASSERT_RETURN(model->plugin == nullptr,);
|
|
model->plugin = this;
|
|
models.push_back(model);
|
|
}
|
|
Model* modelFromJson(json_t* moduleJ) {
|
|
return nullptr;
|
|
}
|
|
std::vector<Plugin*> plugins;
|
|
} // namespace plugin
|
|
} // namespace rack
|
|
|
|
int main()
|
|
{
|
|
Plugin* const p = new Plugin;
|
|
pluginInstance__Befaco = p;
|
|
p->addModel(modelSpringReverb);
|
|
engine::Module* module = modelSpringReverb->createModule();
|
|
|
|
d_stdout("modelSpringReverb is %p %p", modelSpringReverb, module);
|
|
d_stdout("modelSpringReverb has %d ins, %d outs, %d lights, %d params",
|
|
module->getNumInputs(), module->getNumOutputs(), module->getNumLights(), module->getNumParams());
|
|
|
|
for (int i=0; i<module->getNumInputs(); ++i)
|
|
d_stdout(" in %d has name '%s'; description '%s'",
|
|
i+1, module->getInputInfo(i)->getFullName().c_str(), module->getInputInfo(i)->getDescription().c_str());
|
|
|
|
for (int i=0; i<module->getNumOutputs(); ++i)
|
|
d_stdout(" out %d has name '%s'; description '%s'",
|
|
i+1, module->getOutputInfo(i)->getFullName().c_str(), module->getOutputInfo(i)->getDescription().c_str());
|
|
|
|
// for (int i=0; i<module->getNumLights(); ++i)
|
|
// {
|
|
// LightInfo* l = module->getLightInfo(i);
|
|
// DISTRHO_SAFE_ASSERT_CONTINUE(l != nullptr);
|
|
// d_stdout(" light %d has name '%s'; description '%s'",
|
|
// i+1, l->getName().c_str(), l->getDescription().c_str());
|
|
// }
|
|
|
|
for (int i=0; i<module->getNumParams(); ++i)
|
|
{
|
|
ParamQuantity* q = module->getParamQuantity(i);
|
|
d_stdout(" param %d has name '%s'; description '%s'; unit '%s'; min %f; max %f; def %f",
|
|
i+1, q->name.c_str(), q->getDescription().c_str(), q->unit.c_str(),
|
|
q->minValue, q->maxValue, q->defaultValue);
|
|
}
|
|
|
|
Module::ProcessArgs args = {
|
|
48000.0f,
|
|
1.0f / 48000.0f,
|
|
0
|
|
};
|
|
for (int i=0; i<96000; ++i)
|
|
{
|
|
module->process(args);
|
|
++args.frame;
|
|
}
|
|
return 0;
|
|
}
|