IPlugEffect::IPlugEffect(IPlugInstanceInfo instanceInfo)
: IPLUG_CTOR(kNumPublicParams, kNumPrivateParams, kNumPrograms, instanceInfo)
{
TRACE;
//arguments are: name, defaultVal, minVal, maxVal, step, label
GetParam(kGain)->InitDouble("Gain", 50., 0., 100.0, 0.01, "%");
GetParam(kGain)->SetShape(2.);
IGraphics* pGraphics = MakeGraphics(this, kWidth, kHeight);
pGraphics->AttachPanelBackground(&COLOR_GRAY);
IBitmap* knob = pGraphics->LoadPointerToBitmap(KNOB_ID, KNOB_FN, kKnobFrames);
pGraphics->AttachControl(new IKnobMultiControl(this, kGainX, kGainY, kGain, knob));
IColor textColor = IColor(255, 0, 0, 0);
IText textProps4(24, &textColor, "Arial", IText::kStyleNormal, IText::kAlignCenter, 0, IText::kQualityDefault);
pGraphics->AttachControl(new ITextControl(this, DRAW_RECT(80, 44, 220, 84), &textProps4, "Hello IPlug!"));
AttachGraphics(pGraphics);
//MakePreset("preset 1", ... );
MakeDefaultPreset((char *) "-", kNumPrograms);
}
//==============================================================================
int main () {
VertexSimple vertices[BOX_VERTEX_COUNT];
ushort indices[BOX_INDEX_COUNT];
GenerateBox(vertices, arrsize(vertices), indices, arrsize(indices));
const float scale = 0.5f;
for (uint i = 0; i < arrsize(vertices); ++i) {
vertices[i].x *= scale;
vertices[i].y *= scale;
vertices[i].z *= scale;
}
const Rect4i windowRect(0, 0, 800, 600);
IGraphics * graphics = Gphx::GraphicsCreate(L"GraphicsTest", windowRect);
IModel * model = graphics->CreateModel(vertices, arrsize(vertices), indices, arrsize(indices));
while (graphics->Advance()) {
graphics->RenderBegin();
model->Render();
graphics->RenderEnd();
}
delete model;
delete graphics;
_CrtDumpMemoryLeaks();
return 0;
}
void IPlugVST::ResizeGraphics(int w, int h)
{
IGraphics* pGraphics = GetGUI();
if (pGraphics) {
mEditRect.left = mEditRect.top = 0;
mEditRect.right = pGraphics->Width();
mEditRect.bottom = pGraphics->Height();
}
}
void Mesh::drawSkybox()
{
IGraphics *gfx = IGraphics::singletonPtr();
gfx->bindArrayBuffer( m_vbo );
gfx->bindSkyboxMaterial();
gfx->drawArraysTriangles( 0, m_numTris * 3 );
}
uint Billboard::OnDraw (TemporaryStorage& storage, uint group, const ITechnique* tech, void* param, bool insideOut)
{
IGraphics* graphics = mCore->GetGraphics();
Matrix43 mat (graphics->GetViewMatrix());
mat.PreTranslate(mAbsolutePos);
mat.ReplaceScaling(mAbsoluteScale);
graphics->SetModelViewMatrix(mat);
DrawBillboard();
graphics->ResetModelViewMatrix();
return 1;
}
void Mesh::drawPaper( Luddite::HTexture hTexPaper, Luddite::HTexture hTexPlanetMap )
{
IGraphics *gfx = IGraphics::singletonPtr();
gfx->bindPaperTexture( hTexPaper, hTexPlanetMap );
gfx->bindArrayBuffer( m_vbo );
gfx->bindPaperMaterial();
gfx->drawArraysTriangles( 0, m_numTris * 3 );
}
void Mesh::build()
{
IGraphics *gfx = IGraphics::singletonPtr();
m_vbo = gfx->genBuffer();
gfx->bindArrayBuffer( m_vbo );
size_t uiSize = sizeof( MeshVert ) * m_numTris * 3;
// Create the buffer
//glBufferData( GL_ARRAY_BUFFER, uiSize, m_bufferData, m_usage );
gfx->bufferData( uiSize, m_vertData, GL_STATIC_DRAW );
}
void IPlugAAX::ResizeGraphics(int w, int h)
{
IGraphics* pGraphics = GetGUI();
if (pGraphics)
{
AAX_Point oEffectViewSize;
oEffectViewSize.horz = (float) w;
oEffectViewSize.vert = (float) h;
pGraphics->GetViewContainer()->SetViewSize(oEffectViewSize);
OnWindowResize();
}
}
void IPlugStandalone::ResizeGraphics(int w, int h)
{
#ifndef OS_IOS
IGraphics* pGraphics = GetGUI();
if (pGraphics)
{
#ifdef OS_OSX
#define TITLEBAR_BODGE 22
RECT r;
GetWindowRect(gHWND, &r);
SetWindowPos(gHWND, 0, r.left, r.bottom - pGraphics->Height() - TITLEBAR_BODGE, pGraphics->Width(), pGraphics->Height() + TITLEBAR_BODGE, 0);
#endif
OnWindowResize();
}
#endif
}
bool Decal::OnSerializeFrom (const TreeNode& node)
{
IGraphics* graphics = mCore->GetGraphics();
if (graphics == 0) return false;
const String& tag = node.mTag;
const Variable& value = node.mValue;
if (tag == "Shader")
{
SetShader( graphics->GetShader(value.AsString()) );
}
else if (tag == "Color")
{
if (value.IsColor4f())
{
SetColor(value.AsColor4f());
}
else if (value.IsColor4ub())
{
SetColor(value.AsColor4ub());
}
}
else if (tag == "Textures")
{
mTextures.Clear();
if (value.IsStringArray())
{
const Array<String>& list = value.AsStringArray();
for (uint i = 0; i < list.GetSize(); ++i)
{
// Skip legacy functionality
if (!list[i].BeginsWith("[Generated]"))
{
const ITexture* tex = graphics->GetTexture(list[i]);
if (tex != 0) mTextures.Expand() = tex;
}
}
}
}
else return false;
return true;
}
IPlugOpenGL::IPlugOpenGL(IPlugInstanceInfo instanceInfo)
: IPLUG_CTOR(kNumParams, kNumPrograms, instanceInfo), mGain(1.)
{
TRACE;
//arguments are: name, defaultVal, minVal, maxVal, step, label
GetParam(kGain)->InitDouble("Gain", 50., 0., 100.0, 0.01, "%");
GetParam(kGain)->SetShape(2.);
IGraphics* pGraphics = MakeGraphics(this, kWidth, kHeight, 30);
pGraphics->AttachPanelBackground(&COLOR_BLACK);
#ifdef OS_OSX
pGraphics->AttachControl(new IOpenGLTestControl(this, IRECT(10, 10, GUI_WIDTH-10, GUI_HEIGHT-10)));
#endif
AttachGraphics(pGraphics);
//MakePreset("preset 1", ... );
MakeDefaultPreset((char *) "-", kNumPrograms);
}
Synthesis::Synthesis(IPlugInstanceInfo instanceInfo)
: IPLUG_CTOR(kNumParams, kNumPrograms, instanceInfo),
lastVirtualKeyboardNoteNumber(virtualKeyboardMinimumNoteNumber - 1) {
TRACE;
IGraphics* pGraphics = MakeGraphics(this, kWidth, kHeight);
pGraphics->AttachBackground(BG_ID, BG_FN);
IBitmap whiteKeyImage = pGraphics->LoadIBitmap(WHITE_KEY_ID, WHITE_KEY_FN, 6);
IBitmap blackKeyImage = pGraphics->LoadIBitmap(BLACK_KEY_ID, BLACK_KEY_FN);
int keyCoordinates[12] = { 0, 7, 12, 20, 24, 36, 43, 48, 56, 60, 69, 72 };
mVirtualKeyboard = new IKeyboardControl(this, kKeybX, kKeybY, virtualKeyboardMinimumNoteNumber, /* octaves: */ 5, &whiteKeyImage, &blackKeyImage, keyCoordinates);
pGraphics->AttachControl(mVirtualKeyboard);
AttachGraphics(pGraphics);
CreatePresets();
}
// Sets up the text renderer...
void setupTextRendering(IText &text, IGraphics &graphics)
{
// set up the text renderer
TextureHandle fontTextureID = graphics.addTextureData("//assets//texOther//gameFontHalf.png", IMAGE_TEXTURE, false);
ASSERT(fontTextureID != UNDEFINED_TEXTURE_HANDLE);
if(fontTextureID != UNDEFINED_TEXTURE_HANDLE)
{
text.assignTexture(fontTextureID);
}
}
FreakkTrem::FreakkTrem(IPlugInstanceInfo instanceInfo):
IPLUG_CTOR(kNumParams, 0, instanceInfo)
{
TRACE;
//arguments are: name, defaultVal, minVal, maxVal, step, label
GetParam(kGain)->InitDouble("Gain", 1, 0., 1.5, 0.001, ""); // Gain knob offers a little amplification
GetParam(kDepth)->InitDouble("Depth", 0.5, 0., 1., 0.001, "%");
GetParam(kFreq)->InitDouble("Freq", 6, 0., 12, 0.5, "Hz");
GetParam(kModMix)->InitDouble("Mod", 0., 0., 1., 0.01, "S<>C" ); // Mod Mixer
GetParam(kIKnobRotaterControl_def)->InitDouble("IKnobRotaterControl Default", 2., .0, 5., .1, "");
IGraphics* pGraphics = MakeGraphics(this, kW, kH); // MakeGraphics(this, kW, kH);
pGraphics->AttachBackground(BG_ID, BG_FN);
//Attach the IKnobRotaterControl default rotation range
IBitmap bitmap = pGraphics->LoadIBitmap(KNOB_SPEED_ID, KNOB_SPEED_FN);
pGraphics->AttachControl(new IKnobRotaterControl(this, kSpeedKnob_def_X, kSpeedKnob_def_Y, kFreq, &bitmap));
bitmap = pGraphics->LoadIBitmap(KNOB_DEPTH_ID, KNOB_DEPTH_FN);
pGraphics->AttachControl(new IKnobRotaterControl(this, kDepthKnob_def_X, kDepthKnob_def_Y, kDepth, &bitmap));
bitmap = pGraphics->LoadIBitmap(KNOB_GAIN_ID, KNOB_GAIN_FN);
pGraphics->AttachControl(new IKnobRotaterControl(this, kGainKnob_def_X, kGainKnob_def_Y, kGain, &bitmap));
bitmap = pGraphics->LoadIBitmap(KNOB_TYPE_ID, KNOB_TYPE_FN);
pGraphics->AttachControl(new IKnobRotaterControl(this, kTypeKnob_def_X, kTypeKnob_def_Y, kModMix, &bitmap));
//IGraphics* pGraphics = MakeGraphics(this, GUI_WIDTH, GUI_HEIGHT);
//IText textProps(12, &COLOR_BLACK, "Verdana", IText::kStyleNormal, IText::kAlignNear, 0, IText::kQualityNonAntiAliased);
//GenerateKnobGUI(pGraphics, this, &textProps, &COLOR_WHITE, &COLOR_BLACK, 60, 70);
AttachGraphics(pGraphics);
panL = panR = 1;
//mSampleRate = GetSampleRate();
counter=0;
}
MostBasicGUI::MostBasicGUI(IPlugInstanceInfo instanceInfo)
: IPLUG_CTOR(kNumParams, kNumPrograms, instanceInfo), mGain(1.)
{
// add a parameter with type, name, default, min, max, step, unit label
GetParam(kGain)->InitDouble("Gain", 50., 0., 100.0, 0.01, "%");
// create graphics context
IGraphics* pGraphics = MakeGraphics(this, kWidth, kHeight);
// add a coloured background
pGraphics->AttachPanelBackground(&COLOR_RED);
// add a PNG image-based knob control, link to parameter and position on gui
IBitmap knob = pGraphics->LoadIBitmap(KNOB_ID, KNOB_FN, kKnobFrames);
pGraphics->AttachControl(new IKnobMultiControl(this, kGainX, kGainY, kGain, &knob));
// attach graphics context
AttachGraphics(pGraphics);
// create factory presets
MakeDefaultPreset((char *) "-", kNumPrograms);
}
void doPopupMenu()
{
IPopupMenu menu;
IGraphics* gui = mPlug->GetGUI();
menu.AddItem("Save Program...");
menu.AddItem("Save Bank...");
menu.AddSeparator();
menu.AddItem("Load Program...");
menu.AddItem("Load Bank...");
if(gui->CreateIPopupMenu(&menu, &mRECT))
{
int itemChosen = menu.GetChosenItemIdx();
//printf("chosen %i /n", itemChosen);
switch (itemChosen)
{
case 0: //Save Program
char disp[MAX_PRESET_NAME_LEN];
strcpy(disp, mPlug->GetPresetName(mPlug->GetCurrentPresetIdx()));
mPlug->SaveProgramAsFXP(disp);
break;
case 1: //Save Bank
mPlug->SaveBankAsFXB("IPlugChunks Bank");
break;
case 3: //Load Preset
mPlug->LoadProgramFromFXP();
break;
case 4: // Load Bank
mPlug->LoadBankFromFXB();
break;
default:
break;
}
}
}
IPlugChunks::IPlugChunks(IPlugInstanceInfo instanceInfo)
: IPLUG_CTOR(kNumParams, kNumPrograms, instanceInfo), mGain(1.)
{
TRACE;
memset(mSteps, 0, NUM_SLIDERS*sizeof(double));
// Define parameter ranges, display units, labels.
//arguments are: name, defaultVal, minVal, maxVal, step, label
GetParam(kGain)->InitDouble("Gain", 0.0, -70.0, 12.0, 0.1, "dB");
MakePresetFromBlob("Ramp Up", "AAAAAJqZqT8AAAAAmpm5PwAAAIA9Csc/AAAAAAAA0D8AAABA4XrUPwAAAIDC9dg/AAAAwMzM3D8AAAAQ16PgPwAAALBH4eI/AAAA0MzM5D8AAADwUbjmPwAAAAjXo+g/AAAAKFyP6j8AAADMzMzsPwAAAOxRuO4/AAAAAAAA8D8AAAAAAAC8Pg==", 136);
MakePresetFromBlob("Ramp Down", "AAAA7FG47j8AAABI4XrsPwAAALBH4eo/AAAAGK5H6T8AAABwPQrnPwAAANDMzOQ/AAAAwB6F4z8AAAAghevhPwAAAAB7FN4/AAAAgOtR2D8AAABAuB7VPwAAAACuR9E/AAAAgEfhyj8AAAAAhevBPwAAAABSuK4/AAAAAOB6hD8AAAAAAAC8Pg==", 136);
MakePresetFromBlob("Triangle", "AAAAAIXrwT8AAACAR+HKPwAAAEBcj9I/AAAAgBSu1z8AAADA9SjcPwAAABDXo+A/AAAAsEfh4j8AAABQuB7lPwAAAGBmZuY/AAAAMDMz4z8AAAAAAADgPwAAAMD1KNw/AAAAQI/C1T8AAAAArkfRPwAAAICPwsU/AAAAAJqZuT8AAAAAAAAAAA==", 136);
MakePresetFromBlob("Inv Triangle", "AAAAAAAA8D8AAABQuB7tPwAAAKBwPeo/AAAAcD0K5z8AAABA4XrkPwAAAJDC9eA/AAAAwEfh2j8AAABAj8LVPwAAAECPwtU/AAAAwMzM3D8AAAAghevhPwAAANDMzOQ/AAAAgBSu5z8AAACYmZnpPwAAAFyPwu0/AAAAAAAA8D8AAAAAAAAAAA==", 136);
MakePresetFromBlob("Da Endz", "AAAAAAAA8D8AAAAA4HqEPwAAAADgeoQ/AAAAAOB6hD8AAAAA4HqEPwAAAADgeoQ/AAAAAOB6hD8AAAAA4HqEPwAAAADgeoQ/AAAAAOB6hD8AAAAA4HqEPwAAAADgeoQ/AAAAAOB6hD8AAAAA4HqEPwAAAADgeoQ/AAAAAAAA8D8AAAAAAAAAAA==", 136);
MakePresetFromBlob("Alternate", "AAAAAAAA8D8AAAAA4HqEPwAAAAAAAPA/AAAAAOB6hD8AAAAAAADwPwAAAADgeoQ/AAAAAAAA8D8AAAAA4HqEPwAAAAAAAPA/AAAAAOB6hD8AAAAAAADwPwAAAADgeoQ/AAAAAAAA8D8AAAAA4HqEPwAAAAAAAPA/AAAAAOB6hD8AAAAAAAAAAA==", 136);
MakePresetFromBlob("Alt Ramp Down", "AAAAAAAA8D8AAAAA4HqEPwAAALgehes/AAAAAOB6hD8AAACI61HoPwAAAADgeoQ/AAAAQArX4z8AAAAA4HqEPwAAAAAAAOA/AAAAAOB6hD8AAABAuB7VPwAAAADgeoQ/AAAAAKRwzT8AAAAA4HqEPwAAAAAzM8M/AAAAAOB6hD8AAAAAAAAAAA==", 136);
MakePresetFromBlob("Alt Ramp Up", "AAAAgJmZyT8AAAAA4HqEPwAAAIBmZtY/AAAAAOB6hD8AAAAAKVzfPwAAAADgeoQ/AAAAMFyP4j8AAAAA4HqEPwAAAEDheuQ/AAAAAOB6hD8AAADwKFznPwAAAADgeoQ/AAAAIIXr6T8AAAAA4HqEPwAAANijcO0/AAAAAOB6hD8AAAAAAAAAAA==", 136);
IGraphics* pGraphics = MakeGraphics(this, kW, kH);
pGraphics->AttachPanelBackground(&COLOR_BLUE);
mMSlider = new MultiSliderControlV(this, IRECT(10, 10, 170, 110), kDummyParamForMultislider, NUM_SLIDERS, 10, &COLOR_WHITE, &COLOR_BLACK, &COLOR_RED);
pGraphics->AttachControl(mMSlider);
pGraphics->AttachControl(new IVSliderControl(this, IRECT(200, 10, 220, 110), kGain, 20, &COLOR_WHITE, &COLOR_GREEN));
//pGraphics->AttachControl(new ITempPresetSaveButtonControl(this, IRECT(350, 250, 390, 290)));
pGraphics->AttachControl(new PresetFunctionsMenu(this, IRECT(350, 250, 390, 290)));
AttachGraphics(pGraphics);
// call RestorePreset(0) here which will initialize the multislider in the gui and the mSteps array
RestorePreset(0);
}
IPlugEEL::IPlugEEL(IPlugInstanceInfo instanceInfo)
: IPLUG_CTOR(kNumParams, kNumPrograms, instanceInfo), mGain(1.)
{
TRACE;
vm = NSEEL_VM_alloc(); // create virtual machine
mVmOutput = NSEEL_VM_regvar(vm, "x"); // register a variable into vm to get a value out
memset(codetext, 0, 65536);
strcpy(codetext, "x=rand(2)-1.;");
codehandle = NSEEL_code_compile(vm, codetext, 0); // compile code
//arguments are: name, defaultVal, minVal, maxVal, step, label
GetParam(kGain)->InitDouble("Gain", 50., 0., 100.0, 0.01, "%");
GetParam(kGain)->SetShape(2.);
IGraphics* pGraphics = MakeGraphics(this, kWidth, kHeight);
pGraphics->AttachPanelBackground(&COLOR_RED);
IBitmap knob = pGraphics->LoadIBitmap(KNOB_ID, KNOB_FN, kKnobFrames);
pGraphics->AttachControl(new IKnobMultiControl(this, kGainX, kGainY, kGain, &knob));
IRECT textRect(5, 70, kWidth-5, kHeight-5);
IText textProps(15, &COLOR_BLACK, "Arial", IText::kStyleNormal, IText::kAlignNear, 0, IText::kQualityDefault);
mTextControl = new AlgDisplay(this, textRect, &textProps, codetext);
pGraphics->AttachControl(mTextControl);
AttachGraphics(pGraphics);
//MakePreset("preset 1", ... );
MakeDefaultPreset((char *) "-", kNumPrograms);
}
DigitalDistortion::DigitalDistortion(IPlugInstanceInfo instanceInfo)
: IPLUG_CTOR(kNumParams, kNumPrograms, instanceInfo), mDistortionAmount(1.)
{
TRACE;
//arguments are: name, defaultVal, minVal, maxVal, step, label
GetParam(kDistortionAmount)->InitDouble("Distortion Amount", 0.0, 0.0, 99.0, 0.01, "%"); //modified so there is no division by zero
//can give nonlinear behavior to the knob (offsets from center)
GetParam(kDistortionAmount)->SetShape(2.);
//loads a red background to the window with height/width parameters
IGraphics* pGraphics = MakeGraphics(this, kWidth, kHeight);
//pGraphics->AttachPanelBackground(&COLOR_RED);
pGraphics->AttachBackground(BACKGROUND_ID, BACKGROUND_FN);
//creates knob with 60 frames
IBitmap knob = pGraphics->LoadIBitmap(KNOB_ID, KNOB_FN, kKnobFrames);
pGraphics->AttachControl(new IKnobMultiControl(this, kDistortionAmountX, kDistortionAmountY, kDistortionAmount, &knob));
AttachGraphics(pGraphics);
//MakePreset("preset 1", ... );
CreatePresets();
}
void SpaceBass::CreateGraphics() {
IGraphics* pGraphics = MakeGraphics(this, kWidth, kHeight);
pGraphics->AttachBackground(BG_ID, BG_FN);
IBitmap whiteKeyImage = pGraphics->LoadIBitmap(WHITE_KEY_ID, WHITE_KEY_FN, 6);
IBitmap blackKeyImage = pGraphics->LoadIBitmap(BLACK_KEY_ID, BLACK_KEY_FN);
// C# D# F# G# A#
int keyCoordinates[12] = { 0, 10, 17, 30, 35, 52, 61, 68, 79, 85, 97, 102 };
mVirtualKeyboard = new IKeyboardControl(this, kKeybX, kKeybY, virtualKeyboardMinimumNoteNumber, /* octaves: */ 4, &whiteKeyImage, &blackKeyImage, keyCoordinates);
pGraphics->AttachControl(mVirtualKeyboard);
IBitmap waveformBitmap = pGraphics->LoadIBitmap(WAVEFORM_ID, WAVEFORM_FN, 4);
IBitmap filterModeBitmap = pGraphics->LoadIBitmap(FILTERMODE_ID, FILTERMODE_FN, 3);
IBitmap knobBitmap = pGraphics->LoadIBitmap(KNOB_ID, KNOB_FN, 64);
for (int i = 0; i < kNumParams; i++) {
const parameterProperties_struct& properties = parameterProperties[i];
IControl* control;
IBitmap* graphic;
switch (i) {
// Switches:
case mOsc1Waveform:
case mOsc2Waveform:
case mLFOWaveform:
graphic = &waveformBitmap;
control = new ISwitchControl(this, properties.x, properties.y, i, graphic);
break;
case mFilterMode:
graphic = &filterModeBitmap;
control = new ISwitchControl(this, properties.x, properties.y, i, graphic);
break;
// Knobs:
default:
graphic = &knobBitmap;
control = new IKnobMultiControl(this, properties.x, properties.y, i, graphic);
break;
}
pGraphics->AttachControl(control);
}
AttachGraphics(pGraphics);
}
IPlugSideChain::IPlugSideChain(IPlugInstanceInfo instanceInfo)
: IPLUG_CTOR(kNumParams, kNumPrograms, instanceInfo), mGain(1.)
, mPrevL(0.0)
, mPrevR(0.0)
, mPrevLS(0.0)
, mPrevRS(0.0)
{
TRACE;
//arguments are: name, defaultVal, minVal, maxVal, step, label
GetParam(kGain)->InitDouble("Gain", 50., 0., 100.0, 0.01, "%");
GetParam(kGain)->SetShape(2.);
IGraphics* pGraphics = MakeGraphics(this, kWidth, kHeight);
pGraphics->AttachPanelBackground(&COLOR_RED);
IBitmap knob = pGraphics->LoadIBitmap(KNOB_ID, KNOB_FN, kKnobFrames);
IText text = IText(14);
pGraphics->AttachControl(new IKnobMultiControlText(this, IRECT(kGainX, kGainY, kGainX + 48, kGainY + 48 + 20), kGain, &knob, &text));
mMeterIdx_L = pGraphics->AttachControl(new IPeakMeterVert(this, MakeIRect(kMeterL)));
mMeterIdx_R = pGraphics->AttachControl(new IPeakMeterVert(this, MakeIRect(kMeterR)));
mMeterIdx_LS = pGraphics->AttachControl(new IPeakMeterVert(this, MakeIRect(kMeterLS)));
mMeterIdx_RS = pGraphics->AttachControl(new IPeakMeterVert(this, MakeIRect(kMeterRS)));
if (GetAPI() == kAPIVST2) // for VST2 we name individual outputs
{
SetInputLabel(0, "main input L");
SetInputLabel(1, "main input R");
SetInputLabel(2, "sc input L");
SetInputLabel(3, "sc input R");
SetOutputLabel(0, "output L");
SetOutputLabel(1, "output R");
}
else // for AU and VST3 we name buses
{
SetInputBusLabel(0, "main input");
SetInputBusLabel(1, "sc input");
SetOutputBusLabel(0, "output");
}
AttachGraphics(pGraphics);
//MakePreset("preset 1", ... );
MakeDefaultPreset((char *) "-", kNumPrograms);
}
IPlugEffectGUILiveEdit::IPlugEffectGUILiveEdit(IPlugInstanceInfo instanceInfo)
: IPLUG_CTOR(kNumPublicParams, kNumPrivateParams, kNumPrograms, instanceInfo)
{
TRACE;
//arguments are: name, defaultVal, minVal, maxVal, step, label
GetParam(kGain)->InitDouble("Gain", 50., 0., 100.0, 0.01, "%");
GetParam(kGain)->SetShape(2.);
IGraphics* pGraphics = MakeGraphics(this, kWidth, kHeight);
// Here we are attaching our GUI resize control ------------------------------------------------------------------------------
// It is important to create on top of all controls!
AttachGUIResize(new IPlugGUIResize(this, pGraphics, true, 16, 16));
// ---------------------------------------------------------------------------------------------------------------------------
pGraphics->AttachPanelBackground(&COLOR_GRAY);
// Start Live GUI edit
GUI_EDIT_START;
NEW_LAYER;
IRECT knobPosition = DRAW_RECT(80, 110, 128, 158);
IBitmap* knob = pGraphics->LoadPointerToBitmap(KNOB_ID, KNOB_FN, kKnobFrames);
pGraphics->AttachControl(new IKnobMultiControl(this, knobPosition.L, knobPosition.T, kGain, knob));
END;
NEW_LAYER;
IColor textColor = IColor(255, 0, 0, 0);
IText textProps(24, &textColor, "Arial", IText::kStyleNormal, IText::kAlignCenter, 0, IText::kQualityDefault);
pGraphics->AttachControl(new ITextControl(this, DRAW_RECT(50, 20, 190, 60), &textProps, "Hello IPlug!"));
END;
// End Live GUI edit
GUI_EDIT_FINISH;
// Attach GUI live edit control. Use __FILE__ macro to get source file path. You can remove it after you edit your GUI.
pGraphics->AttachControl(new IPlugGUILiveEdit(this, __FILE__, 10));
AttachGraphics(pGraphics);
//MakePreset("preset 1", ... );
MakeDefaultPreset((char *) "-", kNumPrograms);
}
AutoTalent::AutoTalent(IPlugInstanceInfo instanceInfo):
IPLUG_CTOR(kNumParams, kNumPrograms, instanceInfo)
{
TRACE;
//======================================================================================================
init(fs);
IGraphics* pGraphics = MakeGraphics(this, kWidth, kHeight);
// Define parameter ranges, display units, labels.
//arguments are: name, defaultVal, minVal, maxVal, step, label
GetParam(kMix)->InitDouble("Mix", 100., 0., 100., 0.01, "%");
GetParam(kShift)->InitDouble("Transpose", 0.0, -12., 12., 1., "st");
GetParam(kTune)->InitDouble("Fine Tune", 0.0, -100., 100., 1, "ct");
GetParam(kAmount)->InitDouble("Amount", 100., 0., 100., 0.01, "%");
GetParam(kGlide)->InitDouble("Glide", 0.0, 0., 1000., 0.01, "ms");
GetParam(kC)->InitDouble("C", 100., 0., 100., 0.01, "%");
GetParam(kDb)->InitDouble("Db", 100., 0., 100., 0.01, "%");
GetParam(kD)->InitDouble("D", 100., 0., 100., 0.01, "%");
GetParam(kEb)->InitDouble("Eb", 100., 0., 100., 0.01, "%");
GetParam(kE)->InitDouble("E", 100., 0., 100., 0.01, "%");
GetParam(kF)->InitDouble("F", 100., 0., 100., 0.01, "%");
GetParam(kGb)->InitDouble("Gb", 100., 0., 100., 0.01, "%");
GetParam(kG)->InitDouble("G", 100., 0., 100., 0.01, "%");
GetParam(kAb)->InitDouble("Ab", 100., 0., 100., 0.01, "%");
GetParam(kA)->InitDouble("A", 100., 0., 100., 0.01, "%");
GetParam(kBb)->InitDouble("Bb", 100., 0., 100., 0.01, "%");
GetParam(kB)->InitDouble("B", 100., 0., 100., 0.01, "%");
GetParam(kRoot)->InitEnum("Root", 0, 12);
GetParam(kRoot)->SetDisplayText(0, "C");
GetParam(kRoot)->SetDisplayText(1, "Db");
GetParam(kRoot)->SetDisplayText(2, "D");
GetParam(kRoot)->SetDisplayText(3, "Eb");
GetParam(kRoot)->SetDisplayText(4, "E");
GetParam(kRoot)->SetDisplayText(5, "F");
GetParam(kRoot)->SetDisplayText(6, "Gb");
GetParam(kRoot)->SetDisplayText(7, "G");
GetParam(kRoot)->SetDisplayText(8, "Ab");
GetParam(kRoot)->SetDisplayText(9, "A");
GetParam(kRoot)->SetDisplayText(10, "Bb");
GetParam(kRoot)->SetDisplayText(11, "B");
GetParam(kScale)->InitEnum("Scale", 0, 13);
GetParam(kScale)->SetDisplayText(0, "Chromatic");
GetParam(kScale)->SetDisplayText(1, "Major");
GetParam(kScale)->SetDisplayText(2, "Minor");
GetParam(kScale)->SetDisplayText(3, "Dorian");
GetParam(kScale)->SetDisplayText(4, "Mixolydian");
GetParam(kScale)->SetDisplayText(5, "Lydian");
GetParam(kScale)->SetDisplayText(6, "Phrygian");
GetParam(kScale)->SetDisplayText(7, "Locrian");
GetParam(kScale)->SetDisplayText(8, "Harmonic Minor");
GetParam(kScale)->SetDisplayText(9, "Melodic Minor");
GetParam(kScale)->SetDisplayText(10, "Major Pentatonic");
GetParam(kScale)->SetDisplayText(11, "Minor Pentatonic");
GetParam(kScale)->SetDisplayText(12, "Minor Blues");
GetParam(kScale)->SetIsMeta(true);
GetParam(kRoot)->SetIsMeta(true);
IBitmap Knob = pGraphics->LoadIBitmap(KNOB_ID, KNOB_FN, kKnobFrames);
IBitmap KeyC = pGraphics->LoadIBitmap(KEYC_ID, KEYC_FN, 2);
IBitmap KeyD = pGraphics->LoadIBitmap(KEYD_ID, KEYD_FN, 2);
IBitmap KeyE = pGraphics->LoadIBitmap(KEYE_ID, KEYE_FN, 2);
IBitmap KeyF = pGraphics->LoadIBitmap(KEYF_ID, KEYF_FN, 2);
IBitmap KeyG = pGraphics->LoadIBitmap(KEYG_ID, KEYG_FN, 2);
IBitmap KeyA = pGraphics->LoadIBitmap(KEYA_ID, KEYA_FN, 2);
IBitmap KeyB = pGraphics->LoadIBitmap(KEYB_ID, KEYB_FN, 2);
IBitmap KeyBlack = pGraphics->LoadIBitmap(KEYBLACK_ID, KEYBLACK_FN, 2);
Keys[0] = new ISwitchControl(this, kKeyboardX, kKeyboardY, kC, &KeyC);
Keys[1] = new ISwitchControl(this, kKeyboardX + kKeyboardSpacingB, kKeyboardY, kDb, &KeyBlack);
Keys[2] = new ISwitchControl(this, kKeyboardX + kKeyboardSpacingW, kKeyboardY, kD, &KeyD);
Keys[3] = new ISwitchControl(this, kKeyboardX + kKeyboardSpacingW + kKeyboardSpacingB, kKeyboardY, kEb, &KeyBlack);
Keys[4] = new ISwitchControl(this, kKeyboardX + 2 * kKeyboardSpacingW, kKeyboardY, kE, &KeyE);
Keys[5] = new ISwitchControl(this, kKeyboardX + 3 * kKeyboardSpacingW, kKeyboardY, kF, &KeyF);
Keys[6] = new ISwitchControl(this, kKeyboardX + 3 * kKeyboardSpacingW + kKeyboardSpacingB, kKeyboardY, kGb, &KeyBlack);
Keys[7] = new ISwitchControl(this, kKeyboardX + 4 * kKeyboardSpacingW, kKeyboardY, kG, &KeyG);
Keys[8] = new ISwitchControl(this, kKeyboardX + 4 * kKeyboardSpacingW + kKeyboardSpacingB, kKeyboardY, kAb, &KeyBlack);
Keys[9] = new ISwitchControl(this, kKeyboardX + 5 * kKeyboardSpacingW, kKeyboardY, kA, &KeyA);
Keys[10] = new ISwitchControl(this, kKeyboardX + 5 * kKeyboardSpacingW + kKeyboardSpacingB, kKeyboardY, kBb, &KeyBlack);
Keys[11] = new ISwitchControl(this, kKeyboardX + 6 * kKeyboardSpacingW, kKeyboardY, kB, &KeyB);
for (int i=0; i<12; i++) {
pGraphics->AttachControl(Keys[i]);
}
pGraphics->AttachBackground(BACKGROUND_ID, BACKGROUND_FN);
IText caption = IText(14, &COLOR_WHITE, "Futura", IText::kStyleNormal, IText::kAlignCenter);
IText label = IText(14, &COLOR_WHITE, "Futura", IText::kStyleNormal, IText::kAlignNear);
IText title = IText(16, &COLOR_WHITE, "Futura", IText::kStyleNormal, IText::kAlignCenter);
mRootControl = new IPopUpMenuControl(this, IRECT(110, 140, 149, 155), LIGHT_GRAY, COLOR_WHITE, LIGHT_YELLOW, kRoot);
mScaleControl = new IPopUpMenuControl(this, IRECT(197, 140, 300, 155), LIGHT_GRAY, COLOR_WHITE, LIGHT_YELLOW, kScale);
pGraphics->AttachControl(mRootControl);
pGraphics->AttachControl(mScaleControl);
pGraphics->AttachControl(new ITextControl(this, IRECT(77, 141, 110, 154), &label, "Root:"));
pGraphics->AttachControl(new ITextControl(this, IRECT(160, 141, 197, 154), &label, "Scale:"));
//pGraphics->AttachControl(new IKnobMultiControl(this, kKnob1X, kKnobsY, kShift, &Knob));
//pGraphics->AttachControl(new IKnobMultiControl(this, kKnob2X, kKnobsY, kTune, &Knob));
//pGraphics->AttachControl(new IKnobMultiControl(this, kKnob3X, kKnobsY, kAmount, &Knob));
//pGraphics->AttachControl(new IKnobMultiControl(this, kKnob4X, kKnobsY, kGlide, &Knob));
pGraphics->AttachControl(new IKnobMultiControlCaption(this, IRECT(kKnob1X, kKnobsY, kKnob1X+83, kKnobsY+90), kShift, &Knob, &caption, true));
pGraphics->AttachControl(new IKnobMultiControlCaption(this, IRECT(kKnob2X, kKnobsY, kKnob2X+83, kKnobsY+90), kTune, &Knob, &caption, true));
pGraphics->AttachControl(new IKnobMultiControlCaption(this, IRECT(kKnob3X, kKnobsY, kKnob3X+83, kKnobsY+90), kGlide, &Knob, &caption, true));
pGraphics->AttachControl(new IKnobMultiControlCaption(this, IRECT(kKnob4X, kKnobsY, kKnob4X+83, kKnobsY+90), kAmount, &Knob, &caption, true));
pGraphics->AttachControl(new ITextControl(this, IRECT(kKnob1X, kTitlesY, kKnob1X+83, kKnobsY+5), &title, "Transpose"));
pGraphics->AttachControl(new ITextControl(this, IRECT(kKnob2X, kTitlesY, kKnob2X+83, kKnobsY+5), &title, "Fine Tune"));
pGraphics->AttachControl(new ITextControl(this, IRECT(kKnob3X, kTitlesY, kKnob3X+83, kKnobsY+5), &title, "Glide"));
pGraphics->AttachControl(new ITextControl(this, IRECT(kKnob4X, kTitlesY, kKnob4X+83, kKnobsY+5), &title, "Amount"));
IText versionText = IText(10, &LIGHTER_GRAY, "Futura", IText::kStyleNormal, IText::kAlignNear);
pGraphics->AttachControl(new ITextControl(this, IRECT(178, 330, 220, 340), &versionText, version));
AttachGraphics(pGraphics);
//MakePreset("preset 1", ... );
}
void Billboard::DrawBillboard()
{
static float vertices[] =
{
-1.0f, 1.0f,
-1.0f, -1.0f,
1.0f, -1.0f,
1.0f, 1.0f
};
static float texcoords[] =
{
0.0f, 1.0f,
0.0f, 0.0f,
1.0f, 0.0f,
1.0f, 1.0f
};
// Set up active render states
IGraphics* graphics = mCore->GetGraphics();
graphics->SetAlphaCutoff();
graphics->SetActiveShader(0);
graphics->SetActiveMaterial(mTex);
// Set the buffers
graphics->SetActiveVertexAttribute( IGraphics::Attribute::Color, 0 );
graphics->SetActiveVertexAttribute( IGraphics::Attribute::Normal, 0 );
graphics->SetActiveVertexAttribute( IGraphics::Attribute::Tangent, 0 );
graphics->SetActiveVertexAttribute( IGraphics::Attribute::BoneIndex, 0 );
graphics->SetActiveVertexAttribute( IGraphics::Attribute::BoneWeight, 0 );
graphics->SetActiveVertexAttribute( IGraphics::Attribute::TexCoord1, 0 );
graphics->SetActiveVertexAttribute( IGraphics::Attribute::TexCoord0, (Vector2f*)texcoords );
graphics->SetActiveVertexAttribute( IGraphics::Attribute::Vertex, (Vector2f*)vertices );
graphics->SetActiveColor(mColor);
// Draw the glow
graphics->DrawVertices (IGraphics::Primitive::Quad, 4);
}
void Vega::CreateGraphics() {
int keyboardX, keyboardY;
IGraphics* pGraphics = MakeGraphics(this, kWidth, kHeight);
pGraphics->AttachBackground(BACKGROUND_ID, BACKGROUND_FN);
IBitmap knobImage = pGraphics->LoadIBitmap(KNOB_ID, KNOB_FN, kKnobFrames);
IBitmap whiteKeyImage = pGraphics->LoadIBitmap(PIANO_WHT_ID, PIANO_WHT_FN, 6);
IBitmap blackKeyImage = pGraphics->LoadIBitmap(PIANO_BLK_ID, PIANO_BLK_FN);
IBitmap miniKnobImage = pGraphics->LoadIBitmap(MINIKNOB_ID, MINIKNOB_FN, kKnobFrames);
IBitmap waveImage = pGraphics->LoadIBitmap(WAVE_ID, WAVE_FN, 4);
IBitmap slopeImage = pGraphics->LoadIBitmap(SLOPE_ID, SLOPE_FN, 3);
IBitmap voicesImage = pGraphics->LoadIBitmap(VOICES_ID, VOICES_FN, 8);
IBitmap octaveImage = pGraphics->LoadIBitmap(OCTAVE_ID, OCTAVE_FN, 9);
IBitmap noteImage = pGraphics->LoadIBitmap(NOTE_ID, NOTE_FN, 15);
IBitmap passImage = pGraphics->LoadIBitmap(PASS_ID, PASS_FN, 3);
IBitmap sliderImage = pGraphics->LoadIBitmap(SLIDER_ID, SLIDER_FN, 1);
IBitmap buttonGrnImage = pGraphics->LoadIBitmap(BUTTON_ID, BUTTON_FN, 2);
IBitmap buttonAddImage = pGraphics->LoadIBitmap(ADD_ID, ADD_FN, 2);
IBitmap wheelImage = pGraphics->LoadIBitmap(PITCHMOD_ID, PITCHMOD_FN, kKnobFrames);
keyboardY = kHeight - 85;
keyboardX = kWidth - 788;
int keyCoordinates[12] = { 0, 17, 0, 49, 0, 0, 98, 0, 128, 0, 157, 0 };
mVirtualKeyboard = new IKeyboardControl(this, keyboardX, keyboardY, virtualKeyboardMinimumNoteNumber,
4, &whiteKeyImage, &blackKeyImage, keyCoordinates);
pGraphics->AttachControl(mVirtualKeyboard);
for (int i = 0; i < kNumParams; i++) {
const paramProperties& properties = paramProps[i];
IControl* control;
IBitmap* graphic;
switch (i) {
case mOsc1Wave:
case mOsc2Wave:
case mOsc3Wave:
case mLFOWave:
graphic = &waveImage;
control = new IKnobMultiControl(this, properties.x, properties.y, i, graphic);
break;
case mFilterType:
graphic = &passImage;
control = new IKnobMultiControl(this, properties.x, properties.y, i, graphic);
break;
case mFilterSlope:
graphic = &slopeImage;
control = new IKnobMultiControl(this, properties.x, properties.y, i, graphic);
break;
case mOsc1Invert:
case mOsc1Retrig:
case mOsc2Invert:
case mOsc2Retrig:
case mOsc3Invert:
case mOsc3Retrig:
graphic = &buttonGrnImage;
control = new ISwitchControl(this, properties.x, properties.y, i, graphic);
break;
case mVolAttack:
case mVolDecay:
case mVolSustain:
case mVolRelease:
case mFilterAttack:
case mFilterDecay:
case mFilterSustain:
case mFilterRelease:
graphic = &sliderImage;
control = new IFaderControl(this, properties.x, properties.y, 73, i, graphic);
break;
case mOsc1Voices:
case mOsc2Voices:
case mOsc3Voices:
graphic = &voicesImage;
control = new IKnobMultiControl(this, properties.x, properties.y, i, graphic);
break;
case mOsc1Oct:
case mOsc2Oct:
case mOsc3Oct:
graphic = &octaveImage;
control = new IKnobMultiControl(this, properties.x, properties.y, i, graphic);
break;
case mOsc1Pitch:
case mOsc2Pitch:
case mOsc3Pitch:
case mBendRange:
graphic = ¬eImage;
control = new IKnobMultiControl(this, properties.x, properties.y, i, graphic);
break;
case mOsc1Fine:
case mOsc2Fine:
case mOsc3Fine:
case mGlide:
graphic = &miniKnobImage;
control = new IKnobMultiControl(this, properties.x, properties.y, i, graphic);
break;
case mPitchMod:
graphic = &wheelImage;
control = new IKnobMultiControl(this, properties.x, properties.y, i, graphic);
break;
default:
graphic = &knobImage;
control = new IKnobMultiControl(this, properties.x, properties.y, i, graphic);
break;
}
pGraphics->AttachControl(control);
}
AttachGraphics(pGraphics);
}
ATKStereoCompressor::ATKStereoCompressor(IPlugInstanceInfo instanceInfo)
: IPLUG_CTOR(kNumParams, kNumPrograms, instanceInfo),
inLFilter(NULL, 1, 0, false), inRFilter(NULL, 1, 0, false), volumesplitFilter(2), applyGainFilter(2), volumemergeFilter(2), drywetFilter(2), outLFilter(NULL, 1, 0, false), outRFilter(NULL, 1, 0, false)
{
TRACE;
//arguments are: name, defaultVal, minVal, maxVal, step, label
GetParam(kMiddleside)->InitBool("Middle/Side processing", 0, "");
GetParam(kLinkChannels)->InitBool("Link channels", 0, "");
GetParam(kActivateChannel1)->InitBool("Enable Channel 1", 1, "");
GetParam(kActivateChannel2)->InitBool("Enable Channel 2", 1, "");
GetParam(kAttack1)->InitDouble("Attack ch1", 10., 1., 100.0, 0.1, "ms");
GetParam(kAttack1)->SetShape(2.);
GetParam(kRelease1)->InitDouble("Release ch1", 10, 1., 100.0, 0.1, "ms");
GetParam(kRelease1)->SetShape(2.);
GetParam(kThreshold1)->InitDouble("Threshold ch1", 0., -40., 0.0, 0.1, "dB"); // threshold is actually power
GetParam(kThreshold1)->SetShape(2.);
GetParam(kRatio1)->InitDouble("Ratio ch1", 2., 1, 100, 1, "-");
GetParam(kRatio1)->SetShape(2.);
GetParam(kSoftness1)->InitDouble("Softness ch1", -2, -4, 0, 0.1, "-");
GetParam(kSoftness1)->SetShape(2.);
GetParam(kMakeup1)->InitDouble("Makeup Gain ch1", 0, 0, 40, 0.1, "-"); // Makeup is expressed in amplitude
GetParam(kMakeup1)->SetShape(2.);
GetParam(kAttack2)->InitDouble("Attack ch2", 10., 1., 100.0, 0.1, "ms");
GetParam(kAttack2)->SetShape(2.);
GetParam(kRelease2)->InitDouble("Release ch2", 10, 1., 100.0, 0.1, "ms");
GetParam(kRelease2)->SetShape(2.);
GetParam(kThreshold2)->InitDouble("Threshold ch2", 0., -40., 0.0, 0.1, "dB"); // threshold is actually power
GetParam(kThreshold2)->SetShape(2.);
GetParam(kRatio2)->InitDouble("Ratio ch2", 2., 1, 100, 1, "-");
GetParam(kRatio2)->SetShape(2.);
GetParam(kSoftness2)->InitDouble("Softness ch2", -2, -4, 0, 0.1, "-");
GetParam(kSoftness2)->SetShape(2.);
GetParam(kMakeup2)->InitDouble("Makeup Gain ch2", 0, 0, 40, 0.1, "-"); // Makeup is expressed in amplitude
GetParam(kMakeup2)->SetShape(2.);
GetParam(kDryWet)->InitDouble("Dry/Wet", 1, 0, 1, 0.01, "-");
GetParam(kDryWet)->SetShape(1.);
IGraphics* pGraphics = MakeGraphics(this, kWidth, kHeight);
pGraphics->AttachBackground(STEREO_COMPRESSOR_ID, STEREO_COMPRESSOR_FN);
IBitmap knob = pGraphics->LoadIBitmap(KNOB_ID, KNOB_FN, kKnobFrames);
IBitmap knob1 = pGraphics->LoadIBitmap(KNOB1_ID, KNOB1_FN, kKnobFrames);
IBitmap myswitch = pGraphics->LoadIBitmap(SWITCH_ID, SWITCH_FN, 2);
IText text = IText(10, 0, 0, IText::kStyleBold);
pGraphics->AttachControl(new IKnobMultiControlText(this, IRECT(kAttack1X, kAttack1Y, kAttack1X + 43, kAttack1Y + 43 + 21), kAttack1, &knob, &text, "ms"));
pGraphics->AttachControl(new IKnobMultiControlText(this, IRECT(kRelease1X, kRelease1Y, kRelease1X + 43, kRelease1Y + 43 + 21), kRelease1, &knob, &text, "ms"));
pGraphics->AttachControl(new IKnobMultiControlText(this, IRECT(kThreshold1X, kThreshold1Y, kThreshold1X + 43, kThreshold1Y + 43 + 21), kThreshold1, &knob, &text, "dB"));
pGraphics->AttachControl(new IKnobMultiControlText(this, IRECT(kRatio1X, kRatio1Y, kRatio1X + 43, kRatio1Y + 43 + 21), kRatio1, &knob, &text, ""));
pGraphics->AttachControl(new IKnobMultiControl(this, kSoftness1X, kSoftness1Y, kSoftness1, &knob));
pGraphics->AttachControl(new IKnobMultiControlText(this, IRECT(kMakeup1X, kMakeup1Y, kMakeup1X + 43, kMakeup1Y + 43 + 21), kMakeup1, &knob, &text, "dB"));
attack2 = new IKnobMultiControlText(this, IRECT(kAttack2X, kAttack2Y, kAttack2X + 43, kAttack2Y + 43 + 21), kAttack2, &knob, &text, "ms");
pGraphics->AttachControl(attack2);
release2 = new IKnobMultiControlText(this, IRECT(kRelease2X, kRelease2Y, kRelease2X + 43, kRelease2Y + 43 + 21), kRelease2, &knob, &text, "ms");
pGraphics->AttachControl(release2);
threshold2 = new IKnobMultiControlText(this, IRECT(kThreshold2X, kThreshold2Y, kThreshold2X + 43, kThreshold2Y + 43 + 21), kThreshold2, &knob, &text, "dB");
pGraphics->AttachControl(threshold2);
ratio2 = new IKnobMultiControlText(this, IRECT(kRatio2X, kRatio2Y, kRatio2X + 43, kRatio2Y + 43 + 21), kRatio2, &knob, &text, "");
pGraphics->AttachControl(ratio2);
softness2 = new IKnobMultiControl(this, kSoftness2X, kSoftness2Y, kSoftness2, &knob);
pGraphics->AttachControl(softness2);
makeup2 = new IKnobMultiControlText(this, IRECT(kMakeup2X, kMakeup2Y, kMakeup2X + 43, kMakeup2Y + 43 + 21), kMakeup2, &knob, &text, "dB");
pGraphics->AttachControl(makeup2);
pGraphics->AttachControl(new IKnobMultiControl(this, kDryWetX, kDryWetY, kDryWet, &knob1));
pGraphics->AttachControl(new ISwitchControl(this, kMiddlesideX, kMiddlesideY, kMiddleside, &myswitch));
pGraphics->AttachControl(new ISwitchControl(this, kLinkChannelsX, kLinkChannelsY, kLinkChannels, &myswitch));
pGraphics->AttachControl(new ISwitchControl(this, kActivateChannel1X, kActivateChannel1Y, kActivateChannel1, &myswitch));
pGraphics->AttachControl(new ISwitchControl(this, kActivateChannel2X, kActivateChannel2Y, kActivateChannel2, &myswitch));
AttachGraphics(pGraphics);
//MakePreset("preset 1", ... );
MakeDefaultPreset((char *) "-", kNumPrograms);
volumesplitFilter.set_volume(std::sqrt(.5));
volumemergeFilter.set_volume(std::sqrt(.5));
endpoint.add_filter(&outLFilter);
endpoint.add_filter(&outRFilter);
powerFilter1.set_input_port(0, &inLFilter, 0);
gainCompressorFilter1.set_input_port(0, &powerFilter1, 0);
attackReleaseFilter1.set_input_port(0, &gainCompressorFilter1, 0);
applyGainFilter.set_input_port(0, &attackReleaseFilter1, 0);
applyGainFilter.set_input_port(1, &inLFilter, 0);
makeupFilter1.set_input_port(0, &applyGainFilter, 0);
drywetFilter.set_input_port(0, &makeupFilter1, 0);
drywetFilter.set_input_port(1, &inLFilter, 0);
outLFilter.set_input_port(0, &drywetFilter, 0);
powerFilter2.set_input_port(0, &inRFilter, 0);
gainCompressorFilter2.set_input_port(0, &powerFilter2, 0);
attackReleaseFilter2.set_input_port(0, &gainCompressorFilter2, 0);
applyGainFilter.set_input_port(2, &attackReleaseFilter2, 0);
applyGainFilter.set_input_port(3, &inRFilter, 0);
makeupFilter2.set_input_port(0, &applyGainFilter, 1);
drywetFilter.set_input_port(2, &makeupFilter2, 0);
drywetFilter.set_input_port(3, &inRFilter, 0);
outRFilter.set_input_port(0, &drywetFilter, 1);
middlesidesplitFilter.set_input_port(0, &inLFilter, 0);
middlesidesplitFilter.set_input_port(1, &inRFilter, 0);
volumesplitFilter.set_input_port(0, &middlesidesplitFilter, 0);
volumesplitFilter.set_input_port(1, &middlesidesplitFilter, 1);
middlesidemergeFilter.set_input_port(0, &makeupFilter1, 0);
middlesidemergeFilter.set_input_port(1, &makeupFilter2, 0);
volumemergeFilter.set_input_port(0, &middlesidemergeFilter, 0);
volumemergeFilter.set_input_port(1, &middlesidemergeFilter, 1);
sumFilter.set_input_port(0, &powerFilter1, 0);
sumFilter.set_input_port(1, &powerFilter2, 0);
powerFilter1.set_memory(0);
powerFilter2.set_memory(0);
Reset();
}
ATKColoredCompressor::ATKColoredCompressor(IPlugInstanceInfo instanceInfo)
: IPLUG_CTOR(kNumParams, kNumPrograms, instanceInfo),
inFilter(nullptr, 1, 0, false), outFilter(nullptr, 1, 0, false), gainCompressorFilter(1, 256*1024)
{
TRACE;
//arguments are: name, defaultVal, minVal, maxVal, step, label
GetParam(kPower)->InitDouble("Power", 10., 0., 100.0, 0.1, "ms");
GetParam(kPower)->SetShape(2.);
GetParam(kAttack)->InitDouble("Attack", 10., 1., 100.0, 0.1, "ms");
GetParam(kAttack)->SetShape(2.);
GetParam(kRelease)->InitDouble("Release", 10, 1., 100.0, 0.1, "ms");
GetParam(kRelease)->SetShape(2.);
GetParam(kThreshold)->InitDouble("Threshold", 0., -40., 0.0, 0.1, "dB"); // threshold is actually power
GetParam(kSlope)->InitDouble("Slope", 2., 1.5, 100, .1, "-");
GetParam(kSlope)->SetShape(2.);
GetParam(kColored)->InitDouble("Color", 0, -.5, .5, 0.01, "-");
GetParam(kQuality)->InitDouble("Quality", 0.1, 0.01, .2, 0.01, "-");
GetParam(kSoftness)->InitDouble("Softness", -2, -4, 0, 0.1, "-");
GetParam(kSoftness)->SetShape(2.);
GetParam(kMakeup)->InitDouble("Makeup Gain", 0, 0, 40, 0.1, "dB"); // Makeup is expressed in amplitude
GetParam(kDryWet)->InitDouble("Dry/Wet", 1, 0, 1, 0.01, "-");
IGraphics* pGraphics = MakeGraphics(this, kWidth, kHeight);
pGraphics->AttachBackground(COLORED_COMPRESSOR_ID, COLORED_COMPRESSOR_FN);
IBitmap knob = pGraphics->LoadIBitmap(KNOB_ID, KNOB_FN, kKnobFrames);
IBitmap knob1 = pGraphics->LoadIBitmap(KNOB1_ID, KNOB1_FN, kKnobFrames1);
IColor color = IColor(255, 255, 255, 255);
IText text = IText(10, &color, nullptr, IText::kStyleBold);
pGraphics->AttachControl(new IKnobMultiControlText(this, IRECT(kPowerX, kPowerY, kPowerX + 78, kPowerY + 78 + 21), kPower, &knob, &text, "ms"));
pGraphics->AttachControl(new IKnobMultiControlText(this, IRECT(kAttackX, kAttackY, kAttackX + 78, kAttackY + 78 + 21), kAttack, &knob, &text, "ms"));
pGraphics->AttachControl(new IKnobMultiControlText(this, IRECT(kReleaseX, kReleaseY, kReleaseX + 78, kReleaseY + 78 + 21), kRelease, &knob, &text, "ms"));
pGraphics->AttachControl(new IKnobMultiControlText(this, IRECT(kThresholdX, kThresholdY, kThresholdX + 78, kThresholdY + 78 + 21), kThreshold, &knob, &text, "dB"));
pGraphics->AttachControl(new IKnobMultiControlText(this, IRECT(kSlopeX, kSlopeY, kSlopeX + 78, kSlopeY + 78 + 21), kSlope, &knob, &text, ""));
pGraphics->AttachControl(new IKnobMultiControl(this, kSoftnessX, kSoftnessY, kSoftness, &knob));
pGraphics->AttachControl(new IKnobMultiControl(this, kColoredX, kColoredY, kColored, &knob1));
pGraphics->AttachControl(new IKnobMultiControl(this, kQualityX, kQualityY, kQuality, &knob));
pGraphics->AttachControl(new IKnobMultiControlText(this, IRECT(kMakeupX, kMakeupY, kMakeupX + 78, kMakeupY + 78 + 21), kMakeup, &knob, &text, "dB"));
pGraphics->AttachControl(new IKnobMultiControl(this, kDryWetX, kDryWetY, kDryWet, &knob1));
AttachGraphics(pGraphics);
//MakePreset("preset 1", ... );
MakePreset("Serial Compression", 10., 10., 10., 0., 2., .1, 0., .01, 0., 1.);
MakePreset("Parallel Compression", 10., 10., 10., 0., 2., .1, 0., .01, 0., 0.5);
powerFilter.set_input_port(0, &inFilter, 0);
attackReleaseFilter.set_input_port(0, &powerFilter, 0);
gainCompressorFilter.set_input_port(0, &attackReleaseFilter, 0);
applyGainFilter.set_input_port(0, &gainCompressorFilter, 0);
applyGainFilter.set_input_port(1, &inFilter, 0);
volumeFilter.set_input_port(0, &applyGainFilter, 0);
drywetFilter.set_input_port(0, &volumeFilter, 0);
drywetFilter.set_input_port(1, &inFilter, 0);
outFilter.set_input_port(0, &drywetFilter, 0);
Reset();
}
VstIntPtr VSTCALLBACK IPlugVST::VSTDispatcher(AEffect *pEffect, VstInt32 opCode, VstInt32 idx, VstIntPtr value, void *ptr, float opt)
{
// VSTDispatcher is an IPlugVST class member, we can access anything in IPlugVST from here.
IPlugVST* _this = (IPlugVST*) pEffect->object;
if (!_this) {
return 0;
}
IPlugBase::IMutexLock lock(_this);
// Handle a couple of opcodes here to make debugging easier.
switch (opCode) {
case effEditIdle:
case __effIdleDeprecated:
#ifdef USE_IDLE_CALLS
_this->OnIdle();
#endif
return 0;
}
Trace(TRACELOC, "%d(%s):%d:%d", opCode, VSTOpcodeStr(opCode), idx, (int) value);
switch (opCode) {
case effOpen: {
_this->HostSpecificInit();
_this->OnParamReset();
return 0;
}
case effClose: {
lock.Destroy();
DELETE_NULL(_this);
return 0;
}
case effGetParamLabel: {
if (idx >= 0 && idx < _this->NParams())
{
strcpy((char*) ptr, _this->GetParam(idx)->GetLabelForHost());
}
return 0;
}
case effGetParamDisplay: {
if (idx >= 0 && idx < _this->NParams())
{
_this->GetParam(idx)->GetDisplayForHost((char*) ptr);
}
return 0;
}
case effGetParamName: {
if (idx >= 0 && idx < _this->NParams())
{
strcpy((char*) ptr, _this->GetParam(idx)->GetNameForHost());
}
return 0;
}
case effString2Parameter:
{
if (idx >= 0 && idx < _this->NParams())
{
if (ptr)
{
IParam* pParam = _this->GetParam(idx);
double v = VSTString2Parameter(pParam, (char*)ptr);
if (_this->GetGUI()) _this->GetGUI()->SetParameterFromPlug(idx, v, false);
pParam->Set(v);
_this->OnParamChange(idx);
}
return 1;
}
return 0;
}
case effSetSampleRate: {
_this->SetSampleRate(opt);
_this->Reset();
return 0;
}
case effSetBlockSize: {
_this->SetBlockSize(value);
_this->Reset();
return 0;
}
case effMainsChanged: {
if (!value) {
_this->OnActivate(false);
_this->Reset();
}
else {
_this->OnActivate(true);
}
return 0;
}
case effEditGetRect: {
if (ptr && _this->GetGUI()) {
*(ERect**) ptr = &(_this->mEditRect);
return 1;
}
ptr = 0;
return 0;
}
case effEditOpen:
{
IGraphics* pGraphics = _this->GetGUI();
if (pGraphics)
{
#if defined(_WIN32) || defined(IPLUG_NO_CARBON_SUPPORT)
if (!pGraphics->OpenWindow(ptr)) pGraphics=0;
#else // OSX, check if we are in a Cocoa VST host
bool iscocoa = (_this->mHasVSTExtensions&VSTEXT_COCOA);
if (iscocoa && !pGraphics->OpenWindow(ptr)) pGraphics=0;
if (!iscocoa && !pGraphics->OpenWindow(ptr, 0)) pGraphics=0;
#endif
if (pGraphics)
{
_this->OnGUIOpen();
return 1;
}
}
return 0;
}
case effEditClose: {
if (_this->GetGUI()) {
_this->OnGUIClose();
_this->GetGUI()->CloseWindow();
return 1;
}
return 0;
}
case __effIdentifyDeprecated: {
return 'NvEf'; // Random deprecated magic.
}
case effGetChunk: {
BYTE** ppData = (BYTE**) ptr;
if (ppData) {
bool isBank = (!idx);
ByteChunk* pChunk = (isBank ? &(_this->mBankState) : &(_this->mState));
InitializeVSTChunk(pChunk);
bool savedOK = true;
if (isBank) {
_this->ModifyCurrentPreset();
savedOK = _this->SerializePresets(pChunk);
//savedOK = _this->SerializeState(pChunk);
}
else {
savedOK = _this->SerializeState(pChunk);
}
if (savedOK && pChunk->Size()) {
*ppData = pChunk->GetBytes();
return pChunk->Size();
}
}
return 0;
}
case effSetChunk: {
if (ptr) {
bool isBank = (!idx);
ByteChunk* pChunk = (isBank ? &(_this->mBankState) : &(_this->mState));
pChunk->Resize(value);
memcpy(pChunk->GetBytes(), ptr, value);
int pos = 0;
int iplugVer = GetIPlugVerFromChunk(pChunk, &pos);
isBank &= (iplugVer >= 0x010000);
if (isBank) {
pos = _this->UnserializePresets(pChunk, pos);
//pos = _this->UnserializeState(pChunk, pos);
}
else {
pos = _this->UnserializeState(pChunk, pos);
_this->ModifyCurrentPreset();
}
if (pos >= 0) {
_this->RedrawParamControls();
return 1;
}
}
return 0;
}
case effProcessEvents: {
VstEvents* pEvents = (VstEvents*) ptr;
if (pEvents && pEvents->events) {
for (int i = 0; i < pEvents->numEvents; ++i) {
VstEvent* pEvent = pEvents->events[i];
if (pEvent) {
if (pEvent->type == kVstMidiType) {
VstMidiEvent* pME = (VstMidiEvent*) pEvent;
IMidiMsg msg(pME->deltaFrames, pME->midiData[0], pME->midiData[1], pME->midiData[2]);
_this->ProcessMidiMsg(&msg);
//#ifdef TRACER_BUILD
// msg.LogMsg();
//#endif
}
else if (pEvent->type == kVstSysExType) {
VstMidiSysexEvent* pSE = (VstMidiSysexEvent*) pEvent;
ISysEx sysex(pSE->deltaFrames, (const BYTE*)pSE->sysexDump, pSE->dumpBytes);
_this->ProcessSysEx(&sysex);
}
}
}
return 1;
}
return 0;
}
case effCanBeAutomated: {
return 1;
}
case effGetInputProperties: {
if (ptr && idx >= 0 && idx < _this->NInChannels()) {
VstPinProperties* pp = (VstPinProperties*) ptr;
pp->flags = kVstPinIsActive;
if (!(idx%2) && idx < _this->NInChannels()-1)
{
pp->flags |= kVstPinIsStereo;
}
sprintf(pp->label, "Input %d", idx + 1);
return 1;
}
return 0;
}
case effGetOutputProperties: {
if (ptr && idx >= 0 && idx < _this->NOutChannels()) {
VstPinProperties* pp = (VstPinProperties*) ptr;
pp->flags = kVstPinIsActive;
if (!(idx%2) && idx < _this->NOutChannels()-1)
{
pp->flags |= kVstPinIsStereo;
}
sprintf(pp->label, "Output %d", idx + 1);
return 1;
}
return 0;
}
case effGetPlugCategory: {
if (_this->IsInst()) return kPlugCategSynth;
return kPlugCategEffect;
}
case effProcessVarIo: {
// VstVariableIo* pIO = (VstVariableIo*) ptr; // For offline processing (of audio files?)
return 0;
}
case effSetSpeakerArrangement: {
VstSpeakerArrangement* pInputArr = (VstSpeakerArrangement*) value;
VstSpeakerArrangement* pOutputArr = (VstSpeakerArrangement*) ptr;
if (pInputArr) {
int n = pInputArr->numChannels;
_this->SetInputChannelConnections(0, n, true);
_this->SetInputChannelConnections(n, _this->NInChannels() - n, false);
}
if (pOutputArr) {
int n = pOutputArr->numChannels;
_this->SetOutputChannelConnections(0, n, true);
_this->SetOutputChannelConnections(n, _this->NOutChannels() - n, false);
}
return 1;
}
case effGetSpeakerArrangement: {
VstSpeakerArrangement** ppInputArr = (VstSpeakerArrangement**) value;
VstSpeakerArrangement** ppOutputArr = (VstSpeakerArrangement**) ptr;
if (ppInputArr) {
*ppInputArr = &(_this->mInputSpkrArr);
}
if (ppOutputArr) {
*ppOutputArr = &(_this->mOutputSpkrArr);
}
return 1;
}
case effGetEffectName: {
if (ptr) {
strcpy((char*) ptr, _this->GetEffectName());
return 1;
}
return 0;
}
case effGetProductString: {
if (ptr) {
strcpy((char*) ptr, _this->GetProductName());
return 1;
}
return 0;
}
case effGetVendorString: {
if (ptr) {
strcpy((char*) ptr, _this->GetMfrName());
return 1;
}
return 0;
}
case effGetVendorVersion: {
return _this->GetEffectVersion(true);
}
case effCanDo: {
if (ptr) {
Trace(TRACELOC, "VSTCanDo(%s)", (char*) ptr);
if (!strcmp((char*) ptr, "receiveVstTimeInfo")) {
return 1;
}
if (_this->DoesMIDI()) {
if (_this->DoesMIDI() & 1) {
if (!strcmp((char*) ptr, "sendVstEvents") ||
!strcmp((char*) ptr, "sendVstMidiEvent")) {
return 1;
}
}
if (_this->DoesMIDI() <= 2) {
if (!strcmp((char*) ptr, "receiveVstEvents") ||
!strcmp((char*) ptr, "receiveVstMidiEvent")) {
return 1;
}
}
//if (!strcmp((char*) ptr, "midiProgramNames")) {
// return 1;
//}
}
// Support Reaper VST extensions: http://www.reaper.fm/sdk/vst/
if (!strcmp((char*) ptr, "hasCockosExtensions"))
{
_this->mHasVSTExtensions |= VSTEXT_COCKOS;
return 0xbeef0000;
}
else if (!strcmp((char*) ptr, "hasCockosViewAsConfig"))
{
_this->mHasVSTExtensions |= VSTEXT_COCOA;
return 0xbeef0000;
}
}
return 0;
}
case effVendorSpecific: {
switch (idx) {
// Mouse wheel
case 0x73744341: {
if (value == 0x57686565) {
IGraphics* pGraphics = _this->GetGUI();
if (pGraphics) {
return pGraphics->ProcessMouseWheel(opt);
}
}
break;
}
// Support Reaper VST extensions: http://www.reaper.fm/sdk/vst/
case effGetParamDisplay: {
if (ptr) {
if (value >= 0 && value < _this->NParams()) {
_this->GetParam(value)->GetDisplayForHost((double) opt, true, (char*) ptr);
}
return 0xbeef;
}
break;
}
case effString2Parameter: {
if (ptr && value >= 0 && value < _this->NParams()) {
if (*(char*) ptr != '\0') {
IParam* pParam = _this->GetParam(value);
sprintf((char*) ptr, "%.17f", pParam->GetNormalized(VSTString2Parameter(pParam, (char*) ptr)));
}
return 0xbeef;
}
break;
}
case kVstParameterUsesIntStep: {
if (value >= 0 && value < _this->NParams()) {
IParam* pParam = _this->GetParam(value);
switch (pParam->Type()) {
case IParam::kTypeBool: {
return 0xbeef;
}
case IParam::kTypeInt:
case IParam::kTypeEnum: {
double min, max;
pParam->GetBounds(&min, &max);
if (fabs(max - min) < 1.5) {
return 0xbeef;
}
break;
}
}
}
break;
}
}
return 0;
}
case effGetProgram: {
return _this->GetCurrentPresetIdx();
}
case effSetProgram: {
//if (!(_this->DoesStateChunks())) {
_this->ModifyCurrentPreset();
//}
_this->RestorePreset((int) value);
return 0;
}
case effGetProgramNameIndexed: {
strcpy((char*) ptr, _this->GetPresetName(idx));
return (CSTR_NOT_EMPTY((char*) ptr) ? 1 : 0);
}
case effSetProgramName: {
if (ptr) {
_this->ModifyCurrentPreset((char*) ptr);
}
return 0;
}
case effGetProgramName: {
if (ptr) {
int idx = _this->GetCurrentPresetIdx();
strcpy((char*) ptr, _this->GetPresetName(idx));
}
return 0;
}
case effGetMidiKeyName: {
if (ptr) {
MidiKeyName* pMKN = (MidiKeyName*) ptr;
pMKN->keyName[0] = '\0';
if (_this->MidiNoteName(pMKN->thisKeyNumber, pMKN->keyName)) {
return 1;
}
}
return 0;
}
case effGetVstVersion: {
return VST_VERSION;
}
case effBeginSetProgram:
case effEndSetProgram:
case effGetMidiProgramName:
case effHasMidiProgramsChanged:
case effGetMidiProgramCategory:
case effGetCurrentMidiProgram:
case effSetBypass:
default: {
return 0;
}
}
}
VstIntPtr VSTCALLBACK IPlugVST::VSTDispatcher(AEffect *pEffect, VstInt32 opCode, VstInt32 idx, VstIntPtr value, void *ptr, float opt)
{
// VSTDispatcher is an IPlugVST class member, we can access anything in IPlugVST from here.
IPlugVST* _this = (IPlugVST*) pEffect->object;
if (!_this)
{
return 0;
}
IPlugBase::IMutexLock lock(_this);
// Handle a couple of opcodes here to make debugging easier.
switch (opCode)
{
case effEditIdle:
case __effIdleDeprecated:
#ifdef USE_IDLE_CALLS
_this->OnIdle();
#endif
return 0;
}
Trace(TRACELOC, "%d(%s):%d:%d", opCode, VSTOpcodeStr(opCode), idx, (int) value);
switch (opCode)
{
case effOpen:
{
_this->HostSpecificInit();
_this->OnParamReset();
return 0;
}
case effClose:
{
lock.Destroy();
DELETE_NULL(_this);
return 0;
}
case effGetParamLabel:
{
if (idx >= 0 && idx < _this->NParams())
{
strcpy((char*) ptr, _this->GetParam(idx)->GetLabelForHost());
}
return 0;
}
case effGetParamDisplay:
{
if (idx >= 0 && idx < _this->NParams())
{
_this->GetParam(idx)->GetDisplayForHost((char*) ptr);
}
return 0;
}
case effGetParamName:
{
if (idx >= 0 && idx < _this->NParams())
{
strcpy((char*) ptr, _this->GetParam(idx)->GetNameForHost());
}
return 0;
}
//could implement effGetParameterProperties to group parameters, but can't find a host that supports it
// case effGetParameterProperties:
// {
// if (idx >= 0 && idx < _this->NParams())
// {
// VstParameterProperties* props = (VstParameterProperties*) ptr;
//
// props->flags = kVstParameterSupportsDisplayCategory;
// props->category = idx+1;
// props->numParametersInCategory = 1;
// strcpy(props->categoryLabel, "test");
// }
// return 1;
// }
case effGetParameterProperties:
{
if (idx >= 0 && idx < _this->NParams())
{
VstParameterProperties* props = (VstParameterProperties*) ptr;
props->flags = 0;
IParam* pParam = _this->GetParam(idx);
if (pParam->Type() == IParam::kTypeBool) {
props->flags |= kVstParameterIsSwitch;
}
if (pParam->Type() == IParam::kTypeEnum || pParam->Type() == IParam::kTypeInt) {
props->flags |= kVstParameterUsesFloatStep;
int possibleValuesCount = (int) (pParam->GetMax() - pParam->GetMin());
props->stepFloat = 1.0 / possibleValuesCount;
props->smallStepFloat = props->stepFloat;
props->largeStepFloat = props->stepFloat;
}
}
return 1;
}
case effString2Parameter:
{
if (idx >= 0 && idx < _this->NParams())
{
if (ptr)
{
double v;
IParam* pParam = _this->GetParam(idx);
if (pParam->GetNDisplayTexts())
{
int vi;
if (!pParam->MapDisplayText((char*)ptr, &vi)) return 0;
v = (double)vi;
}
else
{
v = atof((char*)ptr);
if (pParam->DisplayIsNegated()) v = -v;
}
if (_this->GetGUI()) _this->GetGUI()->SetParameterFromPlug(idx, v, false);
pParam->Set(v);
_this->OnParamChange(idx);
}
return 1;
}
return 0;
}
case effSetSampleRate:
{
_this->SetSampleRate(opt);
_this->Reset();
return 0;
}
case effSetBlockSize:
{
_this->SetBlockSize(value);
_this->Reset();
return 0;
}
case effMainsChanged:
{
if (!value)
{
_this->OnActivate(false);
_this->Reset();
}
else
{
_this->OnActivate(true);
}
return 0;
}
case effEditGetRect:
{
if (ptr && _this->GetGUI())
{
*(ERect**) ptr = &(_this->mEditRect);
return 1;
}
ptr = 0;
return 0;
}
case effEditOpen:
{
IGraphics* pGraphics = _this->GetGUI();
if (pGraphics)
{
#ifdef _WIN32
if (!pGraphics->OpenWindow(ptr)) pGraphics=0;
#else // OSX, check if we are in a Cocoa VST host
#if defined(__LP64__)
if (!pGraphics->OpenWindow(ptr)) pGraphics=0;
#else
bool iscocoa = (_this->mHasVSTExtensions&VSTEXT_COCOA);
if (iscocoa && !pGraphics->OpenWindow(ptr)) pGraphics=0;
if (!iscocoa && !pGraphics->OpenWindow(ptr, 0)) pGraphics=0;
#endif
#endif
if (pGraphics)
{
_this->OnGUIOpen();
return 1;
}
}
return 0;
}
case effEditClose:
{
if (_this->GetGUI())
{
_this->OnGUIClose();
_this->GetGUI()->CloseWindow();
return 1;
}
return 0;
}
case __effIdentifyDeprecated:
{
return 'NvEf'; // Random deprecated magic.
}
case effGetChunk:
{
BYTE** ppData = (BYTE**) ptr;
if (ppData)
{
bool isBank = (!idx);
ByteChunk* pChunk = (isBank ? &(_this->mBankState) : &(_this->mState));
_this->InitChunkWithIPlugVer(pChunk);
bool savedOK = true;
if (isBank)
{
_this->ModifyCurrentPreset();
savedOK = _this->SerializePresets(pChunk);
}
else
{
savedOK = _this->SerializeState(pChunk);
}
if (savedOK && pChunk->Size())
{
*ppData = pChunk->GetBytes();
return pChunk->Size();
}
}
return 0;
}
case effSetChunk:
{
if (ptr)
{
bool isBank = (!idx);
ByteChunk* pChunk = (isBank ? &(_this->mBankState) : &(_this->mState));
pChunk->Resize(value);
memcpy(pChunk->GetBytes(), ptr, value);
int pos = 0;
int iplugVer = _this->GetIPlugVerFromChunk(pChunk, &pos);
isBank &= (iplugVer >= 0x010000);
if (isBank)
{
pos = _this->UnserializePresets(pChunk, pos);
}
else
{
pos = _this->UnserializeState(pChunk, pos);
_this->ModifyCurrentPreset();
}
if (pos >= 0)
{
_this->RedrawParamControls();
return 1;
}
}
return 0;
}
case effProcessEvents:
{
VstEvents* pEvents = (VstEvents*) ptr;
if (pEvents && pEvents->events)
{
for (int i = 0; i < pEvents->numEvents; ++i)
{
VstEvent* pEvent = pEvents->events[i];
if (pEvent)
{
if (pEvent->type == kVstMidiType)
{
VstMidiEvent* pME = (VstMidiEvent*) pEvent;
IMidiMsg msg(pME->deltaFrames, pME->midiData[0], pME->midiData[1], pME->midiData[2]);
_this->ProcessMidiMsg(&msg);
//#ifdef TRACER_BUILD
// msg.LogMsg();
//#endif
}
else if (pEvent->type == kVstSysExType)
{
VstMidiSysexEvent* pSE = (VstMidiSysexEvent*) pEvent;
ISysEx sysex(pSE->deltaFrames, (const BYTE*)pSE->sysexDump, pSE->dumpBytes);
_this->ProcessSysEx(&sysex);
}
}
}
return 1;
}
return 0;
}
case effCanBeAutomated:
{
return 1;
}
case effGetInputProperties:
{
if (ptr && idx >= 0 && idx < _this->NInChannels())
{
VstPinProperties* pp = (VstPinProperties*) ptr;
pp->flags = kVstPinIsActive;
if (!(idx%2) && idx < _this->NInChannels()-1)
{
pp->flags |= kVstPinIsStereo;
}
if (_this->GetInputLabel(idx)->GetLength())
{
sprintf(pp->label, "%s", _this->GetInputLabel(idx)->Get());
}
else
{
sprintf(pp->label, "Input %d", idx + 1);
}
return 1;
}
return 0;
}
case effGetOutputProperties:
{
if (ptr && idx >= 0 && idx < _this->NOutChannels())
{
VstPinProperties* pp = (VstPinProperties*) ptr;
pp->flags = kVstPinIsActive;
if (!(idx%2) && idx < _this->NOutChannels()-1)
{
pp->flags |= kVstPinIsStereo;
}
if (_this->GetOutputLabel(idx)->GetLength())
{
sprintf(pp->label, "%s", _this->GetOutputLabel(idx)->Get());
}
else
{
sprintf(pp->label, "Output %d", idx + 1);
}
return 1;
}
return 0;
}
case effGetPlugCategory:
{
if (_this->IsInst()) return kPlugCategSynth;
return kPlugCategEffect;
}
case effProcessVarIo:
{
// VstVariableIo* pIO = (VstVariableIo*) ptr; // For offline processing (of audio files?)
return 0;
}
case effSetSpeakerArrangement:
{
VstSpeakerArrangement* pInputArr = (VstSpeakerArrangement*) value;
VstSpeakerArrangement* pOutputArr = (VstSpeakerArrangement*) ptr;
if (pInputArr)
{
int n = pInputArr->numChannels;
_this->SetInputChannelConnections(0, n, true);
_this->SetInputChannelConnections(n, _this->NInChannels() - n, false);
}
if (pOutputArr)
{
int n = pOutputArr->numChannels;
_this->SetOutputChannelConnections(0, n, true);
_this->SetOutputChannelConnections(n, _this->NOutChannels() - n, false);
}
return 1;
}
case effGetSpeakerArrangement:
{
VstSpeakerArrangement** ppInputArr = (VstSpeakerArrangement**) value;
VstSpeakerArrangement** ppOutputArr = (VstSpeakerArrangement**) ptr;
if (ppInputArr)
{
*ppInputArr = &(_this->mInputSpkrArr);
}
if (ppOutputArr)
{
*ppOutputArr = &(_this->mOutputSpkrArr);
}
return 1;
}
case effGetEffectName:
{
if (ptr)
{
strcpy((char*) ptr, _this->GetEffectName());
return 1;
}
return 0;
}
case effGetProductString:
{
if (ptr)
{
strcpy((char*) ptr, _this->GetProductName());
return 1;
}
return 0;
}
case effGetVendorString:
{
if (ptr)
{
strcpy((char*) ptr, _this->GetMfrName());
return 1;
}
return 0;
}
case effCanDo:
{
if (ptr)
{
Trace(TRACELOC, "VSTCanDo(%s)", (char*) ptr);
if (!strcmp((char*) ptr, "receiveVstTimeInfo"))
{
return 1;
}
if (_this->DoesMIDI())
{
if (!strcmp((char*) ptr, "sendVstEvents") ||
!strcmp((char*) ptr, "sendVstMidiEvent") ||
!strcmp((char*) ptr, "receiveVstEvents") ||
!strcmp((char*) ptr, "receiveVstMidiEvent")) // ||
{
//!strcmp((char*) ptr, "midiProgramNames")) {
return 1;
}
}
// Support Reaper VST extensions: http://www.reaper.fm/sdk/vst/
if (!strcmp((char*) ptr, "hasCockosExtensions"))
{
_this->mHasVSTExtensions |= VSTEXT_COCKOS;
return 0xbeef0000;
}
else if (!strcmp((char*) ptr, "hasCockosViewAsConfig"))
{
_this->mHasVSTExtensions |= VSTEXT_COCOA;
return 0xbeef0000;
}
}
return 0;
}
case effGetTailSize:
{
return _this->GetTailSize();
}
case effVendorSpecific:
{
// Support Reaper VST extensions: http://www.reaper.fm/sdk/vst/
if (idx == effGetParamDisplay && ptr)
{
if (value >= 0 && value < _this->NParams())
{
_this->GetParam(value)->GetDisplayForHost((double) opt, true, (char*) ptr);
}
return 0xbeef;
}
if (idx == kVstParameterUsesIntStep)
{
if (value >= 0 && value < _this->NParams())
{
if (_this->GetParam(value)->Type() != IParam::kTypeDouble)
{
return 0xbeef;
}
}
}
return 0;
}
case effGetProgram:
{
return _this->GetCurrentPresetIdx();
}
case effSetProgram:
{
if (_this->DoesStateChunks() == false)
{
_this->ModifyCurrentPreset(); // TODO: test, something is funny about this http://forum.cockos.com/showpost.php?p=485113&postcount=22
}
_this->RestorePreset((int) value);
return 0;
}
case effGetProgramNameIndexed:
{
strcpy((char*) ptr, _this->GetPresetName(idx));
return (CSTR_NOT_EMPTY((char*) ptr) ? 1 : 0);
}
case effSetProgramName:
{
if (ptr)
{
_this->ModifyCurrentPreset((char*) ptr);
_this->PresetsChangedByHost();
}
return 0;
}
case effGetProgramName:
{
if (ptr)
{
int idx = _this->GetCurrentPresetIdx();
strcpy((char*) ptr, _this->GetPresetName(idx));
}
return 0;
}
case effGetMidiKeyName:
{
if (ptr)
{
MidiKeyName* pMKN = (MidiKeyName*) ptr;
pMKN->keyName[0] = '\0';
if (_this->MidiNoteName(pMKN->thisKeyNumber, pMKN->keyName))
{
return 1;
}
}
return 0;
}
case effGetVstVersion:
{
return VST_VERSION;
}
case effEndSetProgram:
case effBeginSetProgram:
case effGetMidiProgramName:
case effHasMidiProgramsChanged:
case effGetMidiProgramCategory:
case effGetCurrentMidiProgram:
case effSetBypass:
default:
{
return 0;
}
}
}
Zstort::Zstort(IPlugInstanceInfo instanceInfo)
: IPLUG_CTOR(kNumParams, kNumPrograms, instanceInfo), mGain(1.)
{
TRACE;
//arguments are: name, defaultVal, minVal, maxVal, step, label
GetParam(kGain)->InitDouble("Gain", 8., 0., 100.0, 0.01, "%");
GetParam(kGain)->SetShape(2.);
GetParam(kTremDepth)->InitDouble("TremDepth", 100., 0., 100.0, 0.01, "%");
GetParam(kTremDepth)->SetShape(2.);
GetParam(kTremFreq)->InitDouble("TremFreq", 4., 0.01, 15, 0.01, "hz");
//GetParam(kTremFreq)->SetShape(2.);
GetParam(kDist)->InitDouble("Distortion", 100., 0.1, 100., 0.01, "%");
GetParam(kDist)->SetShape(2.);
GetParam(kBits)->InitInt("BitRate", 32, 1, 32, "bits");
GetParam(kRate)->InitInt("RateReduction", 1, 1, 32, "x");
IGraphics* pGraphics = MakeGraphics(this, kWidth, kHeight);
pGraphics->AttachPanelBackground(&COLOR_BLACK);
IRECT distRect(kDistX, kDistY - 5, 200, 80.);
IText textProps3(14, &COLOR_RED, "Arial", IText::kStyleItalic, IText::kAlignNear, 0, IText::kQualityDefault);
pGraphics->AttachControl(new ITextControl(this, IRECT(kDistX, kDistY -25, 200, 80), &textProps3, "Distortion"));
pGraphics->AttachControl(new ITextControl(this, IRECT(kGainX, kGainY - 25, 200, 80), &textProps3, "Gain"));
pGraphics->AttachControl(new ITextControl(this, IRECT(kTremDepthX, kTremDepthY - 25, 200, 80), &textProps3, "Tremolo Depth"));
pGraphics->AttachControl(new ITextControl(this, IRECT(kTremFreqX, kTremFreqY - 25, 200, 80), &textProps3, "Tremolo\nFrequency"));
pGraphics->AttachControl(new ITextControl(this, IRECT(kRateX, kRateY - 25, 200, 80), &textProps3, "Sample Rate\nReduction"));
pGraphics->AttachControl(new ITextControl(this, IRECT(kBitsX, kBitsY - 25, 200, 80), &textProps3, "BitCrusher"));
//attempt at updating values live -can't seem to redraw
distIdx = pGraphics->AttachControl(new ITextControl(this, IRECT(200, 300, 200, 80), &textProps3, "Distortion: xx!"));
IBitmap knob = pGraphics->LoadIBitmap(KNOB_ID, KNOB_FN, kKnobFrames);
pGraphics->AttachControl(new IKnobMultiControl(this, kGainX, kGainY, kGain, &knob));
pGraphics->AttachControl(new IKnobMultiControl(this, kTremDepthX, kTremDepthY, kTremDepth, &knob));
pGraphics->AttachControl(new IKnobMultiControl(this, kTremFreqX, kTremFreqY, kTremFreq, &knob));
pGraphics->AttachControl(new IKnobMultiControl(this, kDistX, kDistY, kDist, &knob));
pGraphics->AttachControl(new IKnobMultiControl(this, kBitsX, kBitsY, kBits, &knob));
pGraphics->AttachControl(new IKnobMultiControl(this, kRateX, kRateY, kRate, &knob));
AttachGraphics(pGraphics);
//MakePreset("preset 1", ... );
MakeDefaultPreset((char *) "-", kNumPrograms);
this->distortion = new DistortionProcessor(1.);
this->bitCrusher = new BitCrushProcessor(32);
this->rateReducer = new SampleRateReductionProcessor(1);
this->trem = new TremoloProcessor(4., 1, 2, GetSampleRate());
}
