696 lines
29 KiB
C++
696 lines
29 KiB
C++
#include <JuceHeader.h>
|
||
#include "PluginEditor.h"
|
||
#include "PluginProcessor.h"
|
||
#include "PresetsCode.cpp" // embedded preset data
|
||
|
||
// ============================================================================
|
||
// WaveThumbnail
|
||
void WaveThumbnail::paint (juce::Graphics& g)
|
||
{
|
||
auto bounds = getLocalBounds();
|
||
|
||
if (highlight)
|
||
{
|
||
g.setColour (juce::Colours::darkorange.withAlpha (0.35f));
|
||
g.fillRect (bounds);
|
||
}
|
||
|
||
g.setColour (juce::Colours::darkgrey);
|
||
g.drawRect (bounds);
|
||
|
||
if (table == nullptr || table->empty())
|
||
{
|
||
if (getName().isNotEmpty())
|
||
{
|
||
g.setColour (juce::Colours::grey);
|
||
g.setFont (12.0f);
|
||
g.drawText (getName(), bounds.reduced (2), juce::Justification::centred);
|
||
}
|
||
return;
|
||
}
|
||
|
||
g.setColour (juce::Colours::lime);
|
||
juce::Path p;
|
||
auto r = bounds;
|
||
p.startNewSubPath ((float) r.getX(), (float) r.getCentreY());
|
||
|
||
const int n = (int) table->size();
|
||
for (int i = 0; i < n; i += 32)
|
||
{
|
||
const float x = juce::jmap ((float) i, 0.0f, (float) n, (float) r.getX(), (float) r.getRight());
|
||
const float y = juce::jmap ((*table)[(size_t) i], -1.0f, 1.0f,
|
||
(float) r.getBottom(), (float) r.getY());
|
||
p.lineTo (x, y);
|
||
}
|
||
g.strokePath (p, juce::PathStrokeType (1.2f));
|
||
|
||
if (getName().isNotEmpty())
|
||
{
|
||
g.setColour (juce::Colours::white.withAlpha (0.9f));
|
||
g.setFont (12.0f);
|
||
g.drawText (getName(), bounds.reduced (2), juce::Justification::topRight);
|
||
}
|
||
}
|
||
|
||
// ============================================================================
|
||
// Draw pad (grid + antialiased thick stroke + “ink” interpolation)
|
||
DrawWaveComponent::DrawWaveComponent()
|
||
{
|
||
samples.assign (WavetableSynthAudioProcessor::kTableSize, 0.0f);
|
||
}
|
||
|
||
void DrawWaveComponent::clear()
|
||
{
|
||
std::fill (samples.begin(), samples.end(), 0.0f);
|
||
repaint();
|
||
}
|
||
|
||
void DrawWaveComponent::paint (juce::Graphics& g)
|
||
{
|
||
auto r = getLocalBounds();
|
||
|
||
// background
|
||
g.fillAll (juce::Colours::black.withAlpha (0.35f));
|
||
g.setColour (juce::Colours::darkgrey);
|
||
g.drawRect (r);
|
||
|
||
// grid
|
||
{
|
||
g.setColour (juce::Colours::white.withAlpha (0.08f));
|
||
const int hLines = 8, vLines = 16;
|
||
for (int i = 1; i < hLines; ++i)
|
||
{
|
||
const float y = juce::jmap ((float) i, 0.0f, (float) hLines, (float) r.getY(), (float) r.getBottom());
|
||
g.drawLine ((float) r.getX(), y, (float) r.getRight(), y);
|
||
}
|
||
for (int i = 1; i < vLines; ++i)
|
||
{
|
||
const float x = juce::jmap ((float) i, 0.0f, (float) vLines, (float) r.getX(), (float) r.getRight());
|
||
g.drawLine (x, (float) r.getY(), x, (float) r.getBottom());
|
||
}
|
||
g.setColour (juce::Colours::white.withAlpha (0.15f)); // zero line
|
||
g.drawLine ((float) r.getX(), (float) r.getCentreY(), (float) r.getRight(), (float) r.getCentreY(), 1.2f);
|
||
}
|
||
|
||
if (samples.empty()) return;
|
||
|
||
// path
|
||
g.setColour (juce::Colours::deepskyblue);
|
||
juce::Path p;
|
||
const int n = (int) samples.size();
|
||
p.startNewSubPath ((float) r.getX(),
|
||
juce::jmap (samples[0], -1.0f, 1.0f, (float) r.getBottom(), (float) r.getY()));
|
||
|
||
const int step = 4;
|
||
for (int i = step; i < n; i += step)
|
||
{
|
||
const float x = juce::jmap ((float) i, 0.0f, (float) n - 1, (float) r.getX(), (float) r.getRight());
|
||
const float y = juce::jmap (samples[(size_t) i], -1.0f, 1.0f, (float) r.getBottom(), (float) r.getY());
|
||
p.lineTo (x, y);
|
||
}
|
||
g.strokePath (p, juce::PathStrokeType (2.0f));
|
||
}
|
||
|
||
void DrawWaveComponent::mouseDown (const juce::MouseEvent& e) { lastDrawIndex = -1; drawAt (e); }
|
||
void DrawWaveComponent::mouseDrag (const juce::MouseEvent& e) { drawAt (e); }
|
||
|
||
void DrawWaveComponent::drawAt (const juce::MouseEvent& e)
|
||
{
|
||
auto r = getLocalBounds();
|
||
|
||
const float xNorm = juce::jlimit (0.0f, 1.0f, (e.position.x - (float) r.getX()) / (float) r.getWidth());
|
||
const float yNorm = juce::jlimit (-1.0f, 1.0f,
|
||
juce::jmap (e.position.y, (float) r.getBottom(), (float) r.getY(), -1.0f, 1.0f));
|
||
|
||
const int N = (int) samples.size();
|
||
const int idx = (int) juce::jlimit (0.0f, (float) (N - 1), xNorm * (float) N);
|
||
|
||
// ink interpolation
|
||
if (lastDrawIndex >= 0 && lastDrawIndex != idx)
|
||
{
|
||
const int a = juce::jmin (lastDrawIndex, idx);
|
||
const int b = juce::jmax (lastDrawIndex, idx);
|
||
const float v0 = samples[(size_t) lastDrawIndex];
|
||
const float v1 = yNorm;
|
||
for (int i = a; i <= b; ++i)
|
||
{
|
||
const float t = (b == a ? 1.0f : (float) (i - a) / (float) (b - a));
|
||
setSampleAt (i, juce::jmap (t, v0, v1));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
setSampleAt (idx, yNorm);
|
||
}
|
||
|
||
lastDrawIndex = idx;
|
||
repaint();
|
||
}
|
||
|
||
void DrawWaveComponent::setSampleAt (int idx, float value)
|
||
{
|
||
if ((size_t) idx < samples.size())
|
||
samples[(size_t) idx] = juce::jlimit (-1.0f, 1.0f, value);
|
||
}
|
||
|
||
// ============================================================================
|
||
// Knob L&F
|
||
void MetalKnobLookAndFeel::drawRotarySlider (juce::Graphics& g, int x, int y, int w, int h,
|
||
float pos, float start, float end, juce::Slider& s)
|
||
{
|
||
juce::ignoreUnused (s);
|
||
|
||
const float radius = juce::jmin (w, h) * 0.45f;
|
||
const float cx = (float) x + (float) w * 0.5f;
|
||
const float cy = (float) y + (float) h * 0.5f;
|
||
|
||
g.setColour (juce::Colour (0xff303030));
|
||
g.fillEllipse (cx - radius, cy - radius, radius * 2.0f, radius * 2.0f);
|
||
|
||
juce::ColourGradient grad (juce::Colours::darkgrey, cx, cy - radius,
|
||
juce::Colours::black, cx, cy + radius, true);
|
||
g.setGradientFill (grad);
|
||
g.fillEllipse (cx - radius * 0.95f, cy - radius * 0.95f, radius * 1.9f, radius * 1.9f);
|
||
|
||
g.setColour (juce::Colours::lightgrey.withAlpha (0.8f));
|
||
const int tickCount = 8;
|
||
for (int i = 0; i < tickCount; ++i)
|
||
{
|
||
const float a = juce::MathConstants<float>::twoPi * (float) i / (float) tickCount;
|
||
const float r1 = radius * 1.08f, r2 = radius * 1.25f;
|
||
g.drawLine (cx + r1 * std::cos (a), cy + r1 * std::sin (a),
|
||
cx + r2 * std::cos (a), cy + r2 * std::sin (a), 1.6f);
|
||
}
|
||
|
||
const float angle = start + pos * (end - start);
|
||
juce::Path needle;
|
||
const float rInner = radius * 0.18f;
|
||
const float rOuter = radius * 0.80f;
|
||
needle.addRoundedRectangle (-2.4f, -rOuter, 4.8f, rOuter - rInner, 1.8f);
|
||
juce::AffineTransform t = juce::AffineTransform::rotation (angle).translated (cx, cy);
|
||
g.setColour (juce::Colours::whitesmoke);
|
||
g.fillPath (needle, t);
|
||
}
|
||
|
||
// ============================================================================
|
||
// Helpers
|
||
static void setRotaryRangeBottomLeftToRight (juce::Slider& s)
|
||
{
|
||
const float start = juce::MathConstants<float>::pi * 1.25f;
|
||
const float end = start + juce::MathConstants<float>::pi * 1.5f;
|
||
s.setRotaryParameters (start, end, true);
|
||
}
|
||
|
||
void WavetableSynthAudioProcessorEditor::labelAbove (juce::Label& L, const juce::String& text)
|
||
{
|
||
L.setText (text, juce::dontSendNotification);
|
||
L.setJustificationType (juce::Justification::centred);
|
||
L.setColour (juce::Label::textColourId, juce::Colours::black);
|
||
}
|
||
|
||
juce::Rectangle<int> WavetableSynthAudioProcessorEditor::getTopPanelBounds() const
|
||
{
|
||
return { 0, 0, getWidth(), 80 };
|
||
}
|
||
|
||
// ↓↓↓ reduced bottom panel height so black area is taller
|
||
juce::Rectangle<int> WavetableSynthAudioProcessorEditor::getBottomPanelBounds() const
|
||
{
|
||
const int panelHeight = 220; // was 300
|
||
return { 0, getHeight() - panelHeight, getWidth(), panelHeight };
|
||
}
|
||
|
||
// ============================================================================
|
||
// Editor
|
||
WavetableSynthAudioProcessorEditor::WavetableSynthAudioProcessorEditor (WavetableSynthAudioProcessor& p)
|
||
: juce::AudioProcessorEditor (&p), audioProcessor (p)
|
||
{
|
||
setSize (1150, 740);
|
||
|
||
// MORPH
|
||
morphSlider.setSliderStyle (juce::Slider::LinearHorizontal);
|
||
morphSlider.setTextBoxStyle (juce::Slider::NoTextBox, false, 0, 0);
|
||
morphAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "MORPH", morphSlider);
|
||
addAndMakeVisible (morphSlider);
|
||
|
||
addAndMakeVisible (morphLoopToggle);
|
||
morphLoopToggleAttach = std::make_unique<juce::AudioProcessorValueTreeState::ButtonAttachment> (p.apvts, "MORPH_LOOP_ON", morphLoopToggle);
|
||
|
||
morphLoopMode.addItemList (juce::StringArray { "Forward", "Ping-Pong", "Half Trip" }, 1);
|
||
morphLoopMode.setJustificationType (juce::Justification::centred);
|
||
addAndMakeVisible (morphLoopMode);
|
||
morphLoopModeAttach = std::make_unique<juce::AudioProcessorValueTreeState::ComboBoxAttachment> (p.apvts, "MORPH_LOOP_MODE", morphLoopMode);
|
||
|
||
// MASTER (remove number box below)
|
||
master.setSliderStyle (juce::Slider::Rotary);
|
||
master.setTextBoxStyle (juce::Slider::NoTextBox, false, 0, 0); // << no readout
|
||
master.setLookAndFeel (&metalKnobLNF);
|
||
setRotaryRangeBottomLeftToRight (master);
|
||
addAndMakeVisible (master);
|
||
addAndMakeVisible (lblMaster);
|
||
labelAbove (lblMaster, "Master");
|
||
if (p.apvts.getParameter ("MASTER") != nullptr)
|
||
masterAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "MASTER", master);
|
||
|
||
// quick knob maker (no number boxes on any knobs)
|
||
auto makeKnob = [this](juce::Slider& s)
|
||
{
|
||
s.setSliderStyle (juce::Slider::Rotary);
|
||
s.setTextBoxStyle (juce::Slider::NoTextBox, false, 0, 0);
|
||
s.setLookAndFeel (&metalKnobLNF);
|
||
setRotaryRangeBottomLeftToRight (s);
|
||
addAndMakeVisible (s);
|
||
};
|
||
|
||
for (auto* s : { &cutoffSlider, &attack, &decay, &sustain, &release,
|
||
&lfoRate, &lfoDepth, &fenvA, &fenvD, &fenvS, &fenvR, &fenvAmt,
|
||
&chRate, &chDepth, &chDelay, &chFb, &chMix,
|
||
&rvRoom, &rvDamp, &rvWidth, &rvWet })
|
||
makeKnob (*s);
|
||
|
||
// Attach main parameters
|
||
cutoffAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "CUTOFF", cutoffSlider);
|
||
attAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "ATTACK", attack);
|
||
decAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "DECAY", decay);
|
||
susAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "SUSTAIN", sustain);
|
||
relAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "RELEASE", release);
|
||
|
||
lfoRateAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "LFO_RATE", lfoRate);
|
||
lfoDepthAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "LFO_DEPTH", lfoDepth);
|
||
|
||
fenvAAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "FENV_A", fenvA);
|
||
fenvDAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "FENV_D", fenvD);
|
||
fenvSAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "FENV_S", fenvS);
|
||
fenvRAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "FENV_R", fenvR);
|
||
fenvAmtAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "FENV_AMT", fenvAmt);
|
||
|
||
// FX toggles + params
|
||
addAndMakeVisible (chorusOn);
|
||
addAndMakeVisible (reverbOn);
|
||
chOnAttach = std::make_unique<juce::AudioProcessorValueTreeState::ButtonAttachment> (p.apvts, "CHORUS_ON", chorusOn);
|
||
rvOnAttach = std::make_unique<juce::AudioProcessorValueTreeState::ButtonAttachment> (p.apvts, "REVERB_ON", reverbOn);
|
||
|
||
chRateAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "CH_RATE", chRate);
|
||
chDepthAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "CH_DEPTH", chDepth);
|
||
chDelayAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "CH_DELAY", chDelay);
|
||
chFbAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "CH_FB", chFb);
|
||
chMixAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "CH_MIX", chMix);
|
||
|
||
rvRoomAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "RV_ROOM", rvRoom);
|
||
rvDampAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "RV_DAMP", rvDamp);
|
||
rvWidthAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "RV_WIDTH", rvWidth);
|
||
rvWetAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "RV_WET", rvWet);
|
||
|
||
// Labels
|
||
for (auto* L : { &lblCutoff,&lblAttack,&lblDecay,&lblSustain,&lblRelease,
|
||
&lblLfoRate,&lblLfoDepth,&lblFenvA,&lblFenvD,&lblFenvS,&lblFenvR,&lblFenvAmt,
|
||
&lblChRate,&lblChDepth,&lblChDelay,&lblChFb,&lblChMix,
|
||
&lblRvRoom,&lblRvDamp,&lblRvWidth,&lblRvWet })
|
||
addAndMakeVisible (*L);
|
||
|
||
labelAbove (lblCutoff, "Cutoff"); labelAbove (lblAttack, "Attack");
|
||
labelAbove (lblDecay, "Decay"); labelAbove (lblSustain, "Sustain");
|
||
labelAbove (lblRelease, "Release");
|
||
|
||
labelAbove (lblLfoRate, "LFO Rate"); labelAbove (lblLfoDepth, "LFO Depth");
|
||
labelAbove (lblFenvA, "FEnv A"); labelAbove (lblFenvD, "FEnv D");
|
||
labelAbove (lblFenvS, "FEnv S"); labelAbove (lblFenvR, "FEnv R");
|
||
labelAbove (lblFenvAmt, "FEnv Amt");
|
||
|
||
labelAbove (lblChRate, "Ch Rate"); labelAbove (lblChDepth, "Ch Depth");
|
||
labelAbove (lblChDelay,"Ch Delay"); labelAbove (lblChFb, "Ch FB");
|
||
labelAbove (lblChMix, "Ch Mix");
|
||
|
||
labelAbove (lblRvRoom, "Rev Room"); labelAbove (lblRvDamp, "Rev Damp");
|
||
labelAbove (lblRvWidth,"Rev Width"); labelAbove (lblRvWet, "Rev Wet");
|
||
|
||
// Hidden slot params
|
||
slotAParam.setVisible (false);
|
||
slotBParam.setVisible (false);
|
||
slotCParam.setVisible (false);
|
||
slotAAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "SLOT_A", slotAParam);
|
||
slotBAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "SLOT_B", slotBParam);
|
||
slotCAttach = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment> (p.apvts, "SLOT_C", slotCParam);
|
||
|
||
// Draw pad + buttons + label
|
||
addAndMakeVisible (userDraw);
|
||
addAndMakeVisible (addToBrowser);
|
||
addAndMakeVisible (clearDraw);
|
||
addAndMakeVisible (presetButton);
|
||
addAndMakeVisible (lblDrawWave);
|
||
lblDrawWave.setText ("DRAW WAVE", juce::dontSendNotification);
|
||
lblDrawWave.setColour (juce::Label::textColourId, juce::Colours::white);
|
||
lblDrawWave.setJustificationType (juce::Justification::left);
|
||
|
||
addToBrowser.setLookAndFeel (&flatBtnLNF);
|
||
clearDraw .setLookAndFeel (&flatBtnLNF);
|
||
presetButton.setLookAndFeel (&flatBtnLNF);
|
||
|
||
addToBrowser.onClick = [this]
|
||
{
|
||
const int slotIndex = audioProcessor.addOrReplaceUserWavetable (userDraw.getTable());
|
||
if (slotIndex >= 0)
|
||
{
|
||
const double di = (double) slotIndex;
|
||
switch (activeSlot)
|
||
{
|
||
case 0: slotAParam.setValue (di, juce::sendNotificationAsync); break;
|
||
case 1: slotBParam.setValue (di, juce::sendNotificationAsync); break;
|
||
case 2: slotCParam.setValue (di, juce::sendNotificationAsync); break;
|
||
default: break;
|
||
}
|
||
repaint();
|
||
}
|
||
};
|
||
clearDraw.onClick = [this]{ userDraw.clear(); };
|
||
presetButton.onClick = [this]{ showPresetMenu(); };
|
||
|
||
// Osc2 mute checkbox
|
||
addAndMakeVisible (osc2Mute);
|
||
osc2MuteAttach = std::make_unique<juce::AudioProcessorValueTreeState::ButtonAttachment> (p.apvts, "OSC2_MUTE", osc2Mute);
|
||
|
||
// Thumbnails for A, B, C
|
||
addAndMakeVisible (slotABox);
|
||
addAndMakeVisible (slotBBox);
|
||
addAndMakeVisible (slotCBox);
|
||
slotABox.setName ("A");
|
||
slotBBox.setName ("B");
|
||
slotCBox.setName ("C");
|
||
slotABox.setOnClick ([this]{ setActiveSlot (0); });
|
||
slotBBox.setOnClick ([this]{ setActiveSlot (1); });
|
||
slotCBox.setOnClick ([this]{ setActiveSlot (2); });
|
||
setActiveSlot (0);
|
||
|
||
startTimerHz (30);
|
||
}
|
||
|
||
// ============================================================================
|
||
// Painting & layout
|
||
void WavetableSynthAudioProcessorEditor::paint (juce::Graphics& g)
|
||
{
|
||
g.fillAll (juce::Colours::black);
|
||
|
||
// Top brushed header
|
||
auto top = getTopPanelBounds();
|
||
{
|
||
juce::Colour c1 = juce::Colour::fromRGB (105,105,110);
|
||
juce::Colour c2 = juce::Colour::fromRGB (75,75,80);
|
||
g.setGradientFill (juce::ColourGradient (c1, (float) top.getX(), (float) top.getY(),
|
||
c2, (float) top.getX(), (float) top.getBottom(), false));
|
||
g.fillRect (top);
|
||
g.setColour (juce::Colours::white.withAlpha (0.05f));
|
||
for (int y = top.getY(); y < top.getBottom(); y += 3)
|
||
g.drawLine ((float) top.getX(), (float) y, (float) top.getRight(), (float) y, 1.0f);
|
||
g.setColour (juce::Colours::black.withAlpha (0.6f));
|
||
g.drawRect (top, 2);
|
||
|
||
g.setColour (juce::Colours::white);
|
||
g.setFont (18.0f);
|
||
g.drawText ("RTWAVE - WAVETABLE SYNTH", 12, top.getY() + 14, 400, 22, juce::Justification::left);
|
||
}
|
||
|
||
// Bottom brushed panel (shorter now)
|
||
auto bottom = getBottomPanelBounds();
|
||
{
|
||
juce::Colour c1 = juce::Colour::fromRGB (110,110,115);
|
||
juce::Colour c2 = juce::Colour::fromRGB (70,70,75);
|
||
g.setGradientFill (juce::ColourGradient (c1, (float) bottom.getX(), (float) bottom.getY(),
|
||
c2, (float) bottom.getX(), (float) bottom.getBottom(), false));
|
||
g.fillRect (bottom);
|
||
g.setColour (juce::Colours::white.withAlpha (0.05f));
|
||
for (int y = bottom.getY(); y < bottom.getBottom(); y += 3)
|
||
g.drawLine ((float) bottom.getX(), (float) y, (float) bottom.getRight(), (float) y, 1.0f);
|
||
g.setColour (juce::Colours::black.withAlpha (0.6f));
|
||
g.drawRect (bottom, 2);
|
||
}
|
||
|
||
// Working area
|
||
const int blackTop = top.getBottom();
|
||
const int blackBottom = bottom.getY(); // moved lower => taller black area
|
||
const int leftWidth = getWidth() / 2 - 20;
|
||
const int rightX = leftWidth + 30;
|
||
|
||
// Wave browser grid (4 x 10)
|
||
auto browser = juce::Rectangle<int> (10, blackTop + 8, leftWidth - 20, blackBottom - blackTop - 16);
|
||
g.setColour (juce::Colours::grey);
|
||
g.drawRect (browser);
|
||
|
||
const int cols = 4, rows = 10;
|
||
const int cellW = browser.getWidth() / cols;
|
||
const int cellH = browser.getHeight() / rows;
|
||
browserCells.clear(); browserCells.reserve (cols * rows);
|
||
|
||
const int waveCount = audioProcessor.getWaveTableCount();
|
||
|
||
for (int r = 0; r < rows; ++r)
|
||
for (int c = 0; c < cols; ++c)
|
||
{
|
||
const int idx = r * cols + c;
|
||
auto cell = juce::Rectangle<int> (browser.getX() + c*cellW, browser.getY() + r*cellH, cellW, cellH);
|
||
browserCells.push_back (cell);
|
||
|
||
g.setColour (juce::Colours::darkgrey);
|
||
g.drawRect (cell);
|
||
|
||
if (idx < waveCount)
|
||
{
|
||
if (const auto* tbl = audioProcessor.getPreviewTablePtr (idx))
|
||
{
|
||
g.setColour (juce::Colours::lime);
|
||
juce::Path p; p.startNewSubPath ((float) cell.getX(), (float) cell.getCentreY());
|
||
const int n = (int) tbl->size();
|
||
for (int i = 0; i < n; i += 32)
|
||
{
|
||
const float x = juce::jmap ((float) i, 0.0f, (float) n, (float) cell.getX(), (float) cell.getRight());
|
||
const float y = juce::jmap ((*tbl)[(size_t) i], -1.0f, 1.0f, (float) cell.getBottom(), (float) cell.getY());
|
||
p.lineTo (x, y);
|
||
}
|
||
g.strokePath (p, juce::PathStrokeType (1.0f));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
g.setColour (juce::Colours::darkgrey);
|
||
g.drawLine ((float) cell.getX(), (float) cell.getY(), (float) cell.getRight(), (float) cell.getBottom(), 0.5f);
|
||
g.drawLine ((float) cell.getRight(), (float) cell.getY(), (float) cell.getX(), (float) cell.getBottom(), 0.5f);
|
||
}
|
||
}
|
||
|
||
// Morph bar + label
|
||
g.setColour (juce::Colours::darkred);
|
||
g.fillRect (juce::Rectangle<int> (rightX, blackTop + 6, getWidth() - rightX - 30, 6));
|
||
g.setColour (juce::Colours::white);
|
||
g.setFont (18.0f);
|
||
g.drawText ("MORPH", rightX, blackTop + 14, getWidth() - rightX - 30, 20, juce::Justification::centred);
|
||
}
|
||
|
||
void WavetableSynthAudioProcessorEditor::resized()
|
||
{
|
||
auto top = getTopPanelBounds();
|
||
auto bottom = getBottomPanelBounds();
|
||
|
||
const int blackTop = top.getBottom();
|
||
const int blackBottom = bottom.getY();
|
||
const int leftWidth = getWidth() / 2 - 20;
|
||
const int rightX = leftWidth + 30;
|
||
|
||
// Morph slider + A/B/C thumbnails (taller boxes)
|
||
const int boxH = 28;
|
||
slotABox.setBounds (rightX, blackTop + 6, 130, boxH);
|
||
slotBBox.setBounds (rightX + 140, blackTop + 6, 130, boxH);
|
||
slotCBox.setBounds (rightX + 280, blackTop + 6, 130, boxH);
|
||
|
||
morphSlider.setBounds (rightX, blackTop + boxH + 10, getWidth() - rightX - 30, 18);
|
||
morphLoopToggle.setBounds (rightX, morphSlider.getBottom() + 10, 120, 22);
|
||
morphLoopMode .setBounds (morphLoopToggle.getRight() + 8, morphSlider.getBottom() + 6, 150, 26);
|
||
|
||
// Presets button (top-right)
|
||
presetButton.setBounds (getWidth() - 130 - 10, top.getY() + 24, 130, 28);
|
||
|
||
// Draw pad – taller now due to shorter bottom panel
|
||
const int padTop = morphLoopMode.getBottom() + 10;
|
||
userDraw.setBounds (rightX, padTop, getWidth() - rightX - 16, blackBottom - padTop - 70);
|
||
lblDrawWave.setBounds (userDraw.getX(), userDraw.getY() - 18, 120, 16);
|
||
|
||
// Buttons under the pad
|
||
addToBrowser.setBounds (userDraw.getX() + 220, userDraw.getBottom() + 8, 150, 28);
|
||
clearDraw .setBounds (addToBrowser.getRight() + 12, userDraw.getBottom() + 8, 150, 28);
|
||
|
||
// Toggles bottom-right (stay clear of osc lights)
|
||
const int togglesY = bottom.getY() - 36;
|
||
reverbOn.setBounds (getWidth() - 280, togglesY, 120, 24);
|
||
osc2Mute .setBounds (getWidth() - 140, togglesY, 140, 24);
|
||
chorusOn.setBounds (userDraw.getX(), userDraw.getBottom() + 8, 90, 20);
|
||
|
||
// Header right: Master
|
||
const int masterW = 82;
|
||
lblMaster.setBounds (getWidth() - masterW - 150, top.getY() + 4, 80, 16);
|
||
master .setBounds (getWidth() - masterW - 150, top.getY() + 16, masterW, masterW);
|
||
|
||
// Knob grid (fits the 220 px panel)
|
||
const int left = bottom.getX() + 18;
|
||
const int topY = bottom.getY() + 28;
|
||
const int stepX = 96;
|
||
const int stepY = 108;
|
||
const int knobW = 72, knobH = 72;
|
||
|
||
auto place = [&](int col, int row, juce::Label& L, juce::Slider& S, const char* txt)
|
||
{
|
||
const int x = left + col * stepX;
|
||
const int y = topY + row * stepY;
|
||
L.setText (txt, juce::dontSendNotification);
|
||
L.setJustificationType (juce::Justification::centred);
|
||
L.setColour (juce::Label::textColourId, juce::Colours::black);
|
||
L.setBounds (x, y - 14, 88, 14);
|
||
S.setBounds (x, y, knobW, knobH);
|
||
};
|
||
|
||
// Row 0
|
||
place (0,0, lblCutoff, cutoffSlider, "Cutoff");
|
||
place (1,0, lblAttack, attack, "Attack");
|
||
place (2,0, lblDecay, decay, "Decay");
|
||
place (3,0, lblSustain, sustain, "Sustain");
|
||
place (4,0, lblRelease, release, "Release");
|
||
place (5,0, lblLfoRate, lfoRate, "LFO Rate");
|
||
place (6,0, lblLfoDepth,lfoDepth, "LFO Depth");
|
||
place (7,0, lblFenvA, fenvA, "FEnv A");
|
||
place (8,0, lblFenvD, fenvD, "FEnv D");
|
||
place (9,0, lblFenvS, fenvS, "FEnv S");
|
||
|
||
// Row 1
|
||
place (0,1, lblFenvR, fenvR, "FEnv R");
|
||
place (1,1, lblFenvAmt, fenvAmt, "FEnv Amt");
|
||
place (2,1, lblChRate, chRate, "Ch Rate");
|
||
place (3,1, lblChDepth, chDepth, "Ch Depth");
|
||
place (4,1, lblChDelay, chDelay, "Ch Delay");
|
||
place (5,1, lblChFb, chFb, "Ch FB");
|
||
place (6,1, lblChMix, chMix, "Ch Mix");
|
||
place (7,1, lblRvRoom, rvRoom, "Rev Room");
|
||
place (8,1, lblRvDamp, rvDamp, "Rev Damp");
|
||
place (9,1, lblRvWidth, rvWidth, "Rev Width");
|
||
place (10,1,lblRvWet, rvWet, "Rev Wet");
|
||
}
|
||
|
||
// ============================================================================
|
||
// Interaction
|
||
void WavetableSynthAudioProcessorEditor::mouseDown (const juce::MouseEvent& e)
|
||
{
|
||
handleBrowserClick (e.getPosition());
|
||
}
|
||
|
||
void WavetableSynthAudioProcessorEditor::handleBrowserClick (juce::Point<int> pos)
|
||
{
|
||
const int waveCount = audioProcessor.getWaveTableCount();
|
||
for (size_t i = 0; i < browserCells.size(); ++i)
|
||
{
|
||
if (browserCells[i].contains (pos))
|
||
{
|
||
if ((int) i >= waveCount) return;
|
||
|
||
const double di = (double) i;
|
||
switch (activeSlot)
|
||
{
|
||
case 0: slotAParam.setValue (di, juce::sendNotificationAsync); break;
|
||
case 1: slotBParam.setValue (di, juce::sendNotificationAsync); break;
|
||
case 2: slotCParam.setValue (di, juce::sendNotificationAsync); break;
|
||
default: break;
|
||
}
|
||
|
||
repaint();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
void WavetableSynthAudioProcessorEditor::setActiveSlot (int slotIndex)
|
||
{
|
||
activeSlot = juce::jlimit (0, 2, slotIndex);
|
||
slotABox.setHighlight (activeSlot == 0);
|
||
slotBBox.setHighlight (activeSlot == 1);
|
||
slotCBox.setHighlight (activeSlot == 2);
|
||
}
|
||
|
||
void WavetableSynthAudioProcessorEditor::showPresetMenu()
|
||
{
|
||
juce::PopupMenu root;
|
||
const auto cats = PresetsCode::getCategories();
|
||
|
||
for (size_t ci = 0; ci < cats.size(); ++ci)
|
||
{
|
||
juce::PopupMenu sub;
|
||
const auto& cat = cats[ci];
|
||
for (size_t pi = 0; pi < cat.presets.size(); ++pi)
|
||
sub.addItem ((int) (1000 + ci*100 + pi), cat.presets[pi].name);
|
||
root.addSubMenu (cat.name, sub);
|
||
}
|
||
|
||
root.showMenuAsync (juce::PopupMenu::Options().withTargetComponent (presetButton),
|
||
[this] (int result)
|
||
{
|
||
if (result <= 0) return;
|
||
|
||
const int ci = (result - 1000) / 100;
|
||
const int pi = (result - 1000) % 100;
|
||
const auto cats = PresetsCode::getCategories();
|
||
|
||
if (ci >= 0 && ci < (int) cats.size()
|
||
&& pi >= 0 && pi < (int) cats[(size_t) ci].presets.size())
|
||
{
|
||
PresetsCode::loadPreset (audioProcessor.apvts, cats[(size_t) ci].presets[(size_t) pi]);
|
||
audioProcessor.notifyPresetLoaded(); // if implemented
|
||
setActiveSlot (0);
|
||
}
|
||
});
|
||
}
|
||
|
||
void WavetableSynthAudioProcessorEditor::timerCallback()
|
||
{
|
||
// keep thumbnails in sync if parameters changed externally
|
||
slotABox.setTable (audioProcessor.getPreviewTablePtr ((int) slotAParam.getValue()));
|
||
slotBBox.setTable (audioProcessor.getPreviewTablePtr ((int) slotBParam.getValue()));
|
||
slotCBox.setTable (audioProcessor.getPreviewTablePtr ((int) slotCParam.getValue()));
|
||
|
||
// Morph slider auto-play (as before)
|
||
bool guiLoopOn = morphLoopToggle.getToggleState();
|
||
bool processorLoopOn = false;
|
||
float processorValue = 0.0f;
|
||
|
||
try
|
||
{
|
||
processorLoopOn = audioProcessor.isMorphLoopActive();
|
||
processorValue = audioProcessor.getMorphDisplayValue();
|
||
}
|
||
catch (...) { }
|
||
|
||
const bool loopActive = processorLoopOn || guiLoopOn;
|
||
|
||
if (! morphSlider.isMouseButtonDown() && loopActive)
|
||
{
|
||
float value = processorLoopOn ? processorValue : 0.0f;
|
||
|
||
if (! processorLoopOn)
|
||
{
|
||
const double now = juce::Time::getMillisecondCounterHiRes();
|
||
const double dt = (now - lastTimerMs) * 0.001; // seconds
|
||
lastTimerMs = now;
|
||
|
||
const int mode = morphLoopMode.getSelectedItemIndex(); // 0 FWD, 1 PINGPONG, 2 HALF
|
||
const float speed = 0.25f; // cycles/s
|
||
localMorphPhase = std::fmod (localMorphPhase + speed * (float) dt, 1.0f);
|
||
|
||
switch (mode)
|
||
{
|
||
case 1: value = (localMorphPhase < 0.5f) ? (localMorphPhase * 2.0f)
|
||
: (1.0f - (localMorphPhase - 0.5f) * 2.0f); break;
|
||
case 2: value = 0.5f * localMorphPhase; break;
|
||
default: value = localMorphPhase; break;
|
||
}
|
||
}
|
||
|
||
morphSlider.setValue (value, juce::dontSendNotification);
|
||
}
|
||
|
||
setActiveSlot (activeSlot);
|
||
repaint();
|
||
}
|