audio/gelyk
2
1
Fork 0
mirror of https://codeberg.org/armin/gelyk.git synced 2026-10-11 17:01:53 +02:00
Code Issues Projects Releases Packages Wiki Activity

init

Browse source
This commit is contained in:
Armin 2026-08-29 22:55:17 +02:00
commit 517219e035
6 changed files with 733 additions and 110 deletions
Download patch file Download diff file Expand all files Collapse all files

535
Source/PluginEditor.cpp
View file

@ -3,9 +3,11 @@
namespace gelyk
{
static constexpr float fontScale = 1.4f;
static juce::Font monoFont(float height)
{
return juce::Font(juce::FontOptions(juce::Font::getDefaultMonospacedFontName(), height,
return juce::Font(juce::FontOptions(juce::Font::getDefaultMonospacedFontName(), height * fontScale,
juce::Font::plain));
}
@ -15,13 +17,18 @@ static juce::Font monoFont(float height)
NeonLookAndFeel::NeonLookAndFeel()
{
setColour(juce::Slider::textBoxTextColourId, cyan);
refreshPalette();
}
void NeonLookAndFeel::refreshPalette()
{
setColour(juce::Slider::textBoxTextColourId, cyan());
setColour(juce::Slider::textBoxOutlineColourId, juce::Colours::transparentBlack);
setColour(juce::Slider::textBoxBackgroundColourId, panel);
setColour(juce::ComboBox::backgroundColourId, panel);
setColour(juce::ComboBox::outlineColourId, line);
setColour(juce::ComboBox::textColourId, cyan);
setColour(juce::ComboBox::arrowColourId, cyan);
setColour(juce::Slider::textBoxBackgroundColourId, panel());
setColour(juce::ComboBox::backgroundColourId, panel());
setColour(juce::ComboBox::outlineColourId, line());
setColour(juce::ComboBox::textColourId, cyan());
setColour(juce::ComboBox::arrowColourId, cyan());
}
void NeonLookAndFeel::drawLinearSlider(juce::Graphics& g, int x, int y, int width, int height,
@ -37,7 +44,7 @@ void NeonLookAndFeel::drawLinearSlider(juce::Graphics& g, int x, int y, int widt
const float tw = 2.0f;
juce::Path track;
track.addRoundedRectangle(cx - tw * 0.5f, (float) y, tw, (float) height, 1.0f);
g.setColour(line);
g.setColour(line());
g.fillPath(track);
// Filled region from centre (0 dB) down to the handle, glowing.
@ -46,13 +53,13 @@ void NeonLookAndFeel::drawLinearSlider(juce::Graphics& g, int x, int y, int widt
const float bottom = juce::jmax(midY, sliderPos);
juce::Path fill;
fill.addRoundedRectangle(cx - 3.0f, top, 6.0f, juce::jmax(1.0f, bottom - top), 3.0f);
g.setColour(cyan);
g.setColour(cyan());
g.fillPath(fill);
// Handle.
g.setColour(slider.isMouseOverOrDragging(true) ? violet : cyan);
g.setColour(slider.isMouseOverOrDragging(true) ? violet() : cyan());
g.fillEllipse(cx - 5.0f, sliderPos - 5.0f, 10.0f, 10.0f);
g.setColour(bg);
g.setColour(bg());
g.fillEllipse(cx - 2.0f, sliderPos - 2.0f, 4.0f, 4.0f);
}
else
@ -60,9 +67,9 @@ void NeonLookAndFeel::drawLinearSlider(juce::Graphics& g, int x, int y, int widt
const float th = 2.0f;
juce::Path track;
track.addRoundedRectangle((float) x, y + height * 0.5f - th * 0.5f, (float) width, th, 1.0f);
g.setColour(line);
g.setColour(line());
g.fillPath(track);
g.setColour(cyan);
g.setColour(cyan());
g.drawHorizontalLine((int) (y + height * 0.5f), sliderPos - 5.0f, sliderPos + 5.0f);
}
}
@ -78,17 +85,18 @@ void NeonLookAndFeel::drawRotarySlider(juce::Graphics& g, int x, int y, int widt
const float arcRadius = radius - lineW * 0.5f;
// Background disc.
g.setColour(panel);
g.setColour(panel());
g.fillEllipse(cx - radius, cy - radius, radius * 2.0f, radius * 2.0f);
g.setColour(line);
g.setColour(line());
g.drawEllipse(cx - radius, cy - radius, radius * 2.0f, radius * 2.0f, 1.0f);
// Filled arc (progress).
juce::Path filledArc;
filledArc.addCentredArc(cx, cy, arcRadius, arcRadius, 0.0f,
startAngle, toAngle, true);
startAngle + juce::MathConstants<float>::halfPi,
toAngle + juce::MathConstants<float>::halfPi, true);
juce::PathStrokeType stroke(lineW, juce::PathStrokeType::curved, juce::PathStrokeType::rounded);
g.setColour(slider.isMouseOverOrDragging(true) ? magenta : cyan);
g.setColour(slider.isMouseOverOrDragging(true) ? magenta() : cyan());
g.strokePath(filledArc, stroke);
// Pointer line.
@ -97,13 +105,13 @@ void NeonLookAndFeel::drawRotarySlider(juce::Graphics& g, int x, int y, int widt
pointer.startNewSubPath(cx, cy);
pointer.lineTo(cx + pointerLength * std::cos(toAngle),
cy + pointerLength * std::sin(toAngle));
g.setColour(slider.isMouseOverOrDragging(true) ? violet : bg);
g.setColour(slider.isMouseOverOrDragging(true) ? violet() : cyan());
g.strokePath(pointer, juce::PathStrokeType(juce::jmax(1.5f, radius * 0.07f),
juce::PathStrokeType::curved,
juce::PathStrokeType::rounded));
// Centre hub.
g.setColour(slider.isMouseOverOrDragging(true) ? cyan : line);
g.setColour(slider.isMouseOverOrDragging(true) ? cyan() : line());
g.fillEllipse(cx - 2.0f, cy - 2.0f, 4.0f, 4.0f);
}
@ -112,9 +120,9 @@ void NeonLookAndFeel::drawComboBox(juce::Graphics& g, int width, int height, boo
{
auto corner = 4.0f;
auto bounds = box.getLocalBounds().toFloat();
g.setColour(panel);
g.setColour(panel());
g.fillRoundedRectangle(bounds, corner);
g.setColour(cyan);
g.setColour(cyan());
g.drawRoundedRectangle(bounds, corner, 1.0f);
juce::Rectangle<int> arrowZone(width - 20, 0, 20, height);
@ -122,14 +130,136 @@ void NeonLookAndFeel::drawComboBox(juce::Graphics& g, int width, int height, boo
p.startNewSubPath((float) arrowZone.getX() + 4.0f, (float) arrowZone.getCentreY() - 3.0f);
p.lineTo((float) arrowZone.getCentreX(), (float) arrowZone.getCentreY() + 3.0f);
p.lineTo((float) arrowZone.getX() + 12.0f, (float) arrowZone.getCentreY() - 3.0f);
g.setColour(cyan);
g.setColour(cyan());
g.strokePath(p, juce::PathStrokeType(1.5f));
}
void NeonLookAndFeel::positionComboBoxText(juce::ComboBox& box, juce::Label& label)
{
label.setBounds(2, 1, box.getWidth() - 22, box.getHeight() - 2);
label.setFont(monoFont(13.0f));
label.setFont(monoFont(13.0f * uiScale));
}
// ---------------------------------------------------------------------------
// BandFader
// ---------------------------------------------------------------------------
void BandFader::paint(juce::Graphics& g)
{
const float cx = getWidth() * 0.5f;
const float y = 0.0f;
const float height = (float) getHeight();
const float value = getGain();
const auto start = (float) gainP->getNormalisableRange().start;
const auto end = (float) gainP->getNormalisableRange().end;
const float sliderPos = y + (end - value) / (end - start) * height;
// Track.
const float tw = 2.0f;
g.setColour(lf.line());
g.fillRect(cx - tw * 0.5f, y, tw, height);
// Filled region from centre (0 dB) down to the handle.
const float midY = y + height * 0.5f;
const float top = juce::jmin(midY, sliderPos);
const float bottom = juce::jmax(midY, sliderPos);
g.setColour(lf.cyan());
g.fillRect(cx - 3.0f, top, 6.0f, juce::jmax(1.0f, bottom - top));
// Handle.
g.setColour(hovered || dragging ? lf.violet() : lf.cyan());
g.fillEllipse(cx - 5.0f, sliderPos - 5.0f, 10.0f, 10.0f);
g.setColour(lf.bg());
g.fillEllipse(cx - 2.0f, sliderPos - 2.0f, 4.0f, 4.0f);
}
void BandFader::mouseDown(const juce::MouseEvent& e)
{
if (gainP == nullptr || freqP == nullptr)
return;
if (e.getNumberOfClicks() > 1)
{
*gainP = 0.0f;
repaint();
return;
}
dragging = true;
startGain = (float) gainP->get();
startFreq = (float) freqP->get();
startX = e.getScreenX();
startY = e.getScreenY();
repaint();
}
void BandFader::mouseDrag(const juce::MouseEvent& e)
{
if (!dragging || gainP == nullptr || freqP == nullptr)
return;
const float h = (float) juce::jmax(1, getHeight());
const float dy = (float) (startY - e.getScreenY());
const float span = (float) gainP->getNormalisableRange().end - (float) gainP->getNormalisableRange().start;
const float newGain = juce::jlimit((float) gainP->getNormalisableRange().start,
(float) gainP->getNormalisableRange().end,
startGain + dy / h * span);
if (gainP->get() != newGain)
*gainP = newGain;
const float w = dragWidth > 0.0f ? dragWidth : (float) juce::jmax(1, getWidth());
const float dx = (float) (e.getScreenX() - startX);
// Track 1:1 with the cursor over the full visualizer width: the fader's screen
// position moves by exactly the same number of pixels as the mouse.
const float startXpos = bandFreqToX(startFreq, dragX0, w);
float newFreq = bandXToFreq(startXpos + dx, dragX0, w);
newFreq = juce::jlimit(20.0f, 20000.0f, newFreq);
// Keep the band between its neighbours so they stay ordered left-to-right.
if (onGetFreqBounds != nullptr)
{
const auto [lo, hi] = onGetFreqBounds();
newFreq = juce::jlimit(lo, hi, newFreq);
}
if (std::abs(newFreq - (float) freqP->get()) > 0.5f)
{
*freqP = newFreq;
if (onFreqChange != nullptr)
onFreqChange();
}
repaint();
}
void BandFader::mouseUp(const juce::MouseEvent&)
{
dragging = false;
repaint();
}
void BandFader::mouseEnter(const juce::MouseEvent&)
{
hovered = true;
repaint();
}
void BandFader::mouseExit(const juce::MouseEvent&)
{
hovered = false;
repaint();
}
void BandFader::mouseWheelMove(const juce::MouseEvent&, const juce::MouseWheelDetails& wheel)
{
if (qP == nullptr)
return;
const float delta = (float) (wheel.deltaY * 0.3);
const float lo = (float) qP->getNormalisableRange().start;
const float hi = (float) qP->getNormalisableRange().end;
*qP = juce::jlimit(lo, hi, (float) qP->get() + delta);
}
// ---------------------------------------------------------------------------
@ -143,9 +273,9 @@ GelykEQAudioProcessorEditor::GelykEQAudioProcessorEditor(GelykEQAudioProcessor&
setLookAndFeel(&lookAndFeel);
setOpaque(true);
titleLabel = std::make_unique<juce::Label>("title", "GELYKEQ");
titleLabel = std::make_unique<juce::Label>("title", "GELYK");
titleLabel->setFont(monoFont(26.0f));
titleLabel->setColour(juce::Label::textColourId, lookAndFeel.cyan);
titleLabel->setColour(juce::Label::textColourId, lookAndFeel.cyan());
titleLabel->setJustificationType(juce::Justification::centredLeft);
addAndMakeVisible(*titleLabel);
@ -160,10 +290,69 @@ GelykEQAudioProcessorEditor::GelykEQAudioProcessorEditor(GelykEQAudioProcessor&
scaleBox->onChange = [this] { scaleUI((float) scaleBox->getSelectedId()); };
addAndMakeVisible(*scaleBox);
const struct ColorControl
{
std::unique_ptr<juce::Label>* label;
std::unique_ptr<juce::Slider>* slider;
const char* text;
double min, max, def;
const char* tip;
} colorControls[] = {
{ &waveSensLabel, &waveSensSlider, "SENS", -12.0, 12.0, 0.0, "Live waveform sensitivity (dB)" },
{ &colorHueLabel, &colorHueSlider, "HUE", -0.5, 0.5, 0.0, "Master colour hue shift" },
{ &colorSatLabel, &colorSatSlider, "SAT", 0.0, 1.0, 1.0, "Master colour saturation" },
{ &colorBriLabel, &colorBriSlider, "BRI", 0.5, 1.5, 1.0, "Master colour brightness" },
{ &waveLabel, &waveSlider, "WAVE", 0.0, 1.0, 0.2, "Live waveform opacity" },
};
for (const auto& cc : colorControls)
{
*cc.label = std::make_unique<juce::Label>("ccap", cc.text);
(*cc.label)->setFont(monoFont(8.0f));
(*cc.label)->setColour(juce::Label::textColourId, lookAndFeel.textDim());
(*cc.label)->setJustificationType(juce::Justification::centred);
addAndMakeVisible(**cc.label);
*cc.slider = std::make_unique<juce::Slider>(juce::Slider::LinearHorizontal, juce::Slider::NoTextBox);
(*cc.slider)->setLookAndFeel(&lookAndFeel);
(*cc.slider)->setSliderStyle(juce::Slider::LinearHorizontal);
(*cc.slider)->setRange(cc.min, cc.max, 0.01);
(*cc.slider)->setDoubleClickReturnValue(true, cc.def);
(*cc.slider)->setValue(cc.def, juce::dontSendNotification);
(*cc.slider)->setTooltip(cc.tip);
addAndMakeVisible(**cc.slider);
}
colorHueSlider->onValueChange = [this]
{
lookAndFeel.hueShift = (float) colorHueSlider->getValue();
refreshColors();
};
colorSatSlider->onValueChange = [this]
{
lookAndFeel.saturation = (float) colorSatSlider->getValue();
refreshColors();
};
colorBriSlider->onValueChange = [this]
{
lookAndFeel.brightness = (float) colorBriSlider->getValue();
refreshColors();
};
waveSlider->onValueChange = [this]
{
lookAndFeel.waveformOpacity = (float) waveSlider->getValue();
repaint();
};
waveSensSlider->onValueChange = [this]
{
lookAndFeel.waveSensitivity = (float) waveSensSlider->getValue();
repaint();
};
// Master gain (vertical fader, far right).
masterLabel = std::make_unique<juce::Label>("mlab", "MASTER");
masterLabel->setFont(monoFont(11.0f));
masterLabel->setColour(juce::Label::textColourId, lookAndFeel.magenta);
masterLabel->setColour(juce::Label::textColourId, lookAndFeel.magenta());
masterLabel->setJustificationType(juce::Justification::centred);
master = std::make_unique<juce::Slider>(juce::Slider::LinearVertical, juce::Slider::TextBoxBelow);
master->setLookAndFeel(&lookAndFeel);
@ -173,15 +362,23 @@ GelykEQAudioProcessorEditor::GelykEQAudioProcessorEditor(GelykEQAudioProcessor&
master->setDoubleClickReturnValue(true, 0.0);
addAndMakeVisible(*masterLabel);
addAndMakeVisible(*master);
masterPercent = std::make_unique<juce::Label>("mper", "100%");
masterPercent->setFont(monoFont(10.0f));
masterPercent->setColour(juce::Label::textColourId, lookAndFeel.cyan());
masterPercent->setJustificationType(juce::Justification::centred);
addAndMakeVisible(*masterPercent);
updateMasterPercent();
masterAttachment = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment>(
processor.getAPVTS(), "master", *master);
master->onValueChange = [this] { updateMasterPercent(); };
// Band faders.
const char* const names[numBands] = { "LOW SHELF", "LOW", "LOW-MID", "MID", "HIGH-MID", "HIGH", "HIGH SHELF" };
const char* const freqs[numBands] = { "60", "160", "400", "800", "1.6K", "4K", "10K" };
for (int i = 0; i < numBands; ++i)
{
auto& w = bands[i];
const juce::Colour accent = (i % 2 == 0) ? lookAndFeel.cyan : lookAndFeel.magenta;
const juce::Colour accent = (i % 2 == 0) ? lookAndFeel.cyan() : lookAndFeel.magenta();
w.freqLabel = std::make_unique<juce::Label>("freq", freqs[i]);
w.freqLabel->setFont(monoFont(14.0f).boldened());
@ -190,7 +387,7 @@ GelykEQAudioProcessorEditor::GelykEQAudioProcessorEditor(GelykEQAudioProcessor&
w.gainCaption = std::make_unique<juce::Label>("gname", names[i]);
w.gainCaption->setFont(monoFont(10.0f));
w.gainCaption->setColour(juce::Label::textColourId, lookAndFeel.textDim);
w.gainCaption->setColour(juce::Label::textColourId, lookAndFeel.textDim());
w.gainCaption->setJustificationType(juce::Justification::centred);
w.gainValue = std::make_unique<juce::Label>("gval", "0.0");
@ -200,23 +397,59 @@ GelykEQAudioProcessorEditor::GelykEQAudioProcessorEditor(GelykEQAudioProcessor&
w.qCaption = std::make_unique<juce::Label>("qcap", "Q");
w.qCaption->setFont(monoFont(10.0f));
w.qCaption->setColour(juce::Label::textColourId, lookAndFeel.textDim);
w.qCaption->setColour(juce::Label::textColourId, lookAndFeel.textDim());
w.qCaption->setJustificationType(juce::Justification::centred);
w.qValue = std::make_unique<juce::Label>("qval", "1.00");
w.qValue->setFont(monoFont(10.0f));
w.qValue->setColour(juce::Label::textColourId, lookAndFeel.violet);
w.qValue->setColour(juce::Label::textColourId, lookAndFeel.violet());
w.qValue->setJustificationType(juce::Justification::centred);
w.gain = std::make_unique<juce::Slider>(juce::Slider::LinearVertical, juce::Slider::NoTextBox);
w.gain->setLookAndFeel(&lookAndFeel);
w.gain->setSliderStyle(juce::Slider::LinearVertical);
w.gain->setRange(-24.0, 24.0, 0.01);
w.gain->setDoubleClickReturnValue(true, 0.0);
w.gain->setValue(0.0, juce::dontSendNotification);
w.gain->onValueChange = [this, i]
w.gain = std::make_unique<BandFader>(processor.getAPVTS(),
"gain" + juce::String(i),
"freq" + juce::String(i),
"q" + juce::String(i),
lookAndFeel);
w.gain->onFreqChange = [this]
{
bands[i].gainValue->setText(juce::String(bands[i].gain->getValue(), 1), juce::dontSendNotification);
resized();
};
// Keep bands in left-to-right frequency order: each band can only go up
// to its right-hand neighbour and down to its left-hand neighbour.
w.gain->onGetFreqBounds = [this, i]() -> std::pair<float, float>
{
auto& apvts = processor.getAPVTS();
float lo = 20.0f;
float hi = 20000.0f;
if (i > 0)
lo = apvts.getRawParameterValue("freq" + juce::String(i - 1))->load() * 1.01f;
if (i < numBands - 1)
hi = apvts.getRawParameterValue("freq" + juce::String(i + 1))->load() * 0.99f;
return { juce::jmax(20.0f, lo), juce::jmin(20000.0f, hi) };
};
w.levelValue = std::make_unique<juce::Label>("lval", "0.0");
w.levelValue->setFont(monoFont(10.0f));
w.levelValue->setColour(juce::Label::textColourId, accent);
w.levelValue->setJustificationType(juce::Justification::centred);
w.levelCaption = std::make_unique<juce::Label>("lcap", "LEVEL");
w.levelCaption->setFont(monoFont(10.0f));
w.levelCaption->setColour(juce::Label::textColourId, lookAndFeel.textDim());
w.levelCaption->setJustificationType(juce::Justification::centred);
w.level = std::make_unique<juce::Slider>(juce::Slider::RotaryVerticalDrag, juce::Slider::NoTextBox);
w.level->setLookAndFeel(&lookAndFeel);
w.level->setSliderStyle(juce::Slider::RotaryVerticalDrag);
w.level->setRotaryParameters(2.4f, 6.9f, true); // ~270° sweep
w.level->setRange(-24.0, 24.0, 0.01);
w.level->setDoubleClickReturnValue(true, 0.0);
w.level->setValue(0.0, juce::dontSendNotification);
w.level->setTooltip("Gain (level), also adjustable via the fader");
w.level->onValueChange = [this, i]
{
updateGainValue(i);
};
w.q = std::make_unique<juce::Slider>(juce::Slider::RotaryVerticalDrag, juce::Slider::NoTextBox);
@ -233,12 +466,12 @@ GelykEQAudioProcessorEditor::GelykEQAudioProcessorEditor(GelykEQAudioProcessor&
w.freqCaption = std::make_unique<juce::Label>("fcap", "FREQ");
w.freqCaption->setFont(monoFont(10.0f));
w.freqCaption->setColour(juce::Label::textColourId, lookAndFeel.textDim);
w.freqCaption->setColour(juce::Label::textColourId, lookAndFeel.textDim());
w.freqCaption->setJustificationType(juce::Justification::centred);
w.freqValue = std::make_unique<juce::Label>("fval", "160");
w.freqValue->setFont(monoFont(10.0f));
w.freqValue->setColour(juce::Label::textColourId, lookAndFeel.cyan);
w.freqValue->setColour(juce::Label::textColourId, lookAndFeel.cyan());
w.freqValue->setJustificationType(juce::Justification::centred);
w.freq = std::make_unique<juce::Slider>(juce::Slider::RotaryVerticalDrag, juce::Slider::NoTextBox);
@ -258,12 +491,16 @@ GelykEQAudioProcessorEditor::GelykEQAudioProcessorEditor(GelykEQAudioProcessor&
else
txt = juce::String((int) f);
bands[i].freqValue->setText(txt, juce::dontSendNotification);
bands[i].freqLabel->setText(txt, juce::dontSendNotification);
};
addAndMakeVisible(*w.freqLabel);
addAndMakeVisible(*w.gainCaption);
addAndMakeVisible(*w.gainValue);
addAndMakeVisible(*w.gain);
addAndMakeVisible(*w.levelValue);
addAndMakeVisible(*w.levelCaption);
addAndMakeVisible(*w.level);
addAndMakeVisible(*w.freqCaption);
addAndMakeVisible(*w.freqValue);
addAndMakeVisible(*w.freq);
@ -271,8 +508,8 @@ GelykEQAudioProcessorEditor::GelykEQAudioProcessorEditor(GelykEQAudioProcessor&
addAndMakeVisible(*w.q);
addAndMakeVisible(*w.qValue);
gainAttachments[i] = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment>(
processor.getAPVTS(), "gain" + juce::String(i), *w.gain);
levelAttachments[i] = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment>(
processor.getAPVTS(), "gain" + juce::String(i), *w.level);
qAttachments[i] = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment>(
processor.getAPVTS(), "q" + juce::String(i), *w.q);
freqAttachments[i] = std::make_unique<juce::AudioProcessorValueTreeState::SliderAttachment>(
@ -282,13 +519,13 @@ GelykEQAudioProcessorEditor::GelykEQAudioProcessorEditor(GelykEQAudioProcessor&
// Status bar.
statusGit = std::make_unique<juce::Label>("git", processor.getGitInfo());
statusGit->setFont(monoFont(11.0f));
statusGit->setColour(juce::Label::textColourId, lookAndFeel.textDim);
statusGit->setColour(juce::Label::textColourId, lookAndFeel.textDim());
statusGit->setJustificationType(juce::Justification::centredRight);
statusBar = std::make_unique<juce::Label>("status",
"GELYKEQ v" + juce::String(ProjectInfo::versionString) + " | ANALYSER");
"GELYK v" + juce::String(ProjectInfo::versionString) + "");
statusBar->setFont(monoFont(11.0f));
statusBar->setColour(juce::Label::textColourId, lookAndFeel.cyan.withAlpha(0.8f));
statusBar->setColour(juce::Label::textColourId, lookAndFeel.cyan().withAlpha(0.8f));
statusBar->setJustificationType(juce::Justification::centredLeft);
addAndMakeVisible(*statusBar);
addAndMakeVisible(*statusGit);
@ -298,6 +535,7 @@ GelykEQAudioProcessorEditor::GelykEQAudioProcessorEditor(GelykEQAudioProcessor&
eqCurve.resize(128);
startTimerHz(30);
refreshColors();
scaleUI(100.0f);
}
@ -332,12 +570,95 @@ void GelykEQAudioProcessorEditor::rebuildFaders()
{
}
void GelykEQAudioProcessorEditor::updateGainValue(int i)
{
const juce::String txt(juce::String(bands[i].level->getValue(), 1));
bands[i].gainValue->setText(txt, juce::dontSendNotification);
bands[i].levelValue->setText(txt, juce::dontSendNotification);
}
void GelykEQAudioProcessorEditor::updateMasterPercent()
{
const float db = (float) master->getValue();
const float percent = std::pow(10.0f, db / 20.0f) * 100.0f;
masterPercent->setText(juce::String(percent, 0) + "%", juce::dontSendNotification);
}
void GelykEQAudioProcessorEditor::refreshColors()
{
lookAndFeel.refreshPalette();
titleLabel->setColour(juce::Label::textColourId, lookAndFeel.cyan());
masterLabel->setColour(juce::Label::textColourId, lookAndFeel.magenta());
masterPercent->setColour(juce::Label::textColourId, lookAndFeel.cyan());
// The scale dropdown and the master value readout read their text colour from
// the LookAndFeel at construction, so they must be re-applied explicitly here
// for the saturation (and hue/brightness) faders to affect them.
scaleBox->setColour(juce::ComboBox::textColourId, lookAndFeel.cyan());
master->setColour(juce::Slider::textBoxTextColourId, lookAndFeel.cyan());
master->setColour(juce::Slider::textBoxBackgroundColourId, lookAndFeel.panel());
statusBar->setColour(juce::Label::textColourId, lookAndFeel.cyan().withAlpha(0.8f));
statusGit->setColour(juce::Label::textColourId, lookAndFeel.textDim());
colorHueLabel->setColour(juce::Label::textColourId, lookAndFeel.cyan());
colorSatLabel->setColour(juce::Label::textColourId, lookAndFeel.magenta());
colorBriLabel->setColour(juce::Label::textColourId, lookAndFeel.violet());
waveLabel->setColour(juce::Label::textColourId, lookAndFeel.textDim());
waveSensLabel->setColour(juce::Label::textColourId, lookAndFeel.textDim());
for (int i = 0; i < numBands; ++i)
{
auto& w = bands[i];
const juce::Colour accent = (i % 2 == 0) ? lookAndFeel.cyan() : lookAndFeel.magenta();
w.freqLabel->setColour(juce::Label::textColourId, accent);
w.gainCaption->setColour(juce::Label::textColourId, lookAndFeel.textDim());
w.gainValue->setColour(juce::Label::textColourId, accent);
w.levelCaption->setColour(juce::Label::textColourId, lookAndFeel.textDim());
w.levelValue->setColour(juce::Label::textColourId, accent);
w.qCaption->setColour(juce::Label::textColourId, lookAndFeel.textDim());
w.qValue->setColour(juce::Label::textColourId, lookAndFeel.violet());
w.freqCaption->setColour(juce::Label::textColourId, lookAndFeel.textDim());
w.freqValue->setColour(juce::Label::textColourId, lookAndFeel.cyan());
}
repaint();
}
void GelykEQAudioProcessorEditor::scaleUI(float percent)
{
const float s = percent / 100.0f;
scaling.store(s);
lookAndFeel.uiScale = s;
setSize((int) (1180 * s), (int) (640 * s));
resized();
refreshFonts(s);
}
void GelykEQAudioProcessorEditor::refreshFonts(float s)
{
titleLabel->setFont(monoFont(26.0f * s));
masterLabel->setFont(monoFont(11.0f * s));
statusGit->setFont(monoFont(11.0f * s));
statusBar->setFont(monoFont(11.0f * s));
colorHueLabel->setFont(monoFont(8.0f * s));
colorSatLabel->setFont(monoFont(8.0f * s));
colorBriLabel->setFont(monoFont(8.0f * s));
waveLabel->setFont(monoFont(8.0f * s));
waveSensLabel->setFont(monoFont(8.0f * s));
for (int i = 0; i < numBands; ++i)
{
auto& w = bands[i];
w.freqLabel->setFont(monoFont(14.0f * s).boldened());
w.gainCaption->setFont(monoFont(10.0f * s));
w.gainValue->setFont(monoFont(11.0f * s));
w.levelCaption->setFont(monoFont(10.0f * s));
w.levelValue->setFont(monoFont(10.0f * s));
w.qCaption->setFont(monoFont(10.0f * s));
w.qValue->setFont(monoFont(10.0f * s));
w.freqCaption->setFont(monoFont(10.0f * s));
w.freqValue->setFont(monoFont(10.0f * s));
}
repaint();
}
void GelykEQAudioProcessorEditor::resized()
@ -354,6 +675,18 @@ void GelykEQAudioProcessorEditor::resized()
titleLabel->setBounds(header.removeFromLeft((int) (180 * s)).reduced(pad, 0));
scaleBox->setBounds(header.removeFromRight((int) (90 * s)).reduced((int)(6*s), (int)(9*s)));
// Colour controls, just left of the scaling dropdown.
juce::Rectangle<int> colorArea = header.removeFromRight((int) (360 * s)).reduced((int)(2*s), (int)(9*s));
std::unique_ptr<juce::Slider>* colorSliders[] = { &waveSensSlider, &colorHueSlider, &colorSatSlider, &colorBriSlider, &waveSlider };
std::unique_ptr<juce::Label>* colorLabels[] = { &waveSensLabel, &colorHueLabel, &colorSatLabel, &colorBriLabel, &waveLabel };
int cellW = colorArea.getWidth() / 5;
for (int i = 0; i < 5; ++i)
{
juce::Rectangle<int> cell = colorArea.removeFromLeft(cellW);
(*colorLabels[i])->setBounds(cell.removeFromTop((int)(13*s)));
(*colorSliders[i])->setBounds(cell);
}
// Footer.
juce::Rectangle<int> footer = area.removeFromBottom(footerH);
footer.reduce(pad, 0);
@ -375,48 +708,66 @@ void GelykEQAudioProcessorEditor::resized()
for (int i = 0; i < numBands; ++i)
{
auto& w = bands[i];
const int captionH = (int) (20 * s);
const int valueH = (int) (17 * s);
const int freqH = (int) (23 * s);
const int knobStackH = (int) (16 * s) + (int)(48 * s) + (int)(12 * s); // value + knob + caption
// Fixed, evenly spaced column for all labels and the knob row.
juce::Rectangle<int> col(x0 + i * (colW + gap), y0, colW, height);
const int captionH = (int) (18 * s);
const int valueH = (int) (15 * s);
const int freqH = (int) (20 * s);
const int knobStackH = (int) (14 * s) + (int)(58 * s) + (int)(12 * s); // value + knob + caption
w.gainCaption->setBounds(col.removeFromTop(captionH));
w.gainValue->setBounds(col.removeFromTop(valueH));
// The gain fader fills the large analyser area (spectrum drawn behind it).
w.gain->setBounds(col.removeFromTop(col.getHeight() - freqH - knobStackH - (int)(6*s)));
// Only the fader slides horizontally to the band's frequency on the shared
// log axis; everything below stays anchored to the fixed column.
juce::Rectangle<int> body = col;
const int faderH = body.getHeight() - freqH - knobStackH - (int)(6 * s);
w.freqLabel->setBounds(col.removeFromTop(freqH));
const float f = processor.getAPVTS().getRawParameterValue("freq" + juce::String(i))->load();
const int cx = (int) bandFreqToX(f, (float) x0, (float) totalW);
const int faderX = juce::jlimit(x0, x0 + totalW - colW, cx - colW / 2);
w.gain->setBounds(faderX, body.getY(), colW, faderH);
w.gain->setDragSpace((float) x0, (float) totalW);
// Bottom control row: FREQ and Q knobs side by side.
juce::Rectangle<int> knobRow = col;
juce::Rectangle<int> rest = col;
rest.removeFromTop(faderH + (int)(6 * s));
w.freqLabel->setBounds(rest.removeFromTop(freqH));
// Bottom control row: LEVEL, FREQ and Q knobs side by side.
juce::Rectangle<int> knobRow = rest;
bandSections[i] = knobRow.toFloat();
int rowW = knobRow.getWidth();
int halfW = rowW / 2;
int thirdW = rowW / 3;
// FREQ (left half).
juce::Rectangle<int> freqCol = knobRow.removeFromLeft(halfW);
w.freqValue->setBounds(freqCol.removeFromTop((int)(14*s)));
w.freq->setBounds(freqCol.removeFromTop((int)(58*s)).reduced((int)(colW*0.08f), 0));
// LEVEL (left third).
juce::Rectangle<int> levelCol = knobRow.removeFromLeft(thirdW);
w.levelValue->setBounds(levelCol.removeFromTop((int)(16*s)));
w.level->setBounds(levelCol.removeFromTop((int)(48*s)).reduced((int)(colW*0.08f), 0));
w.levelCaption->setBounds(levelCol.removeFromTop((int)(12*s)));
// FREQ (middle third).
juce::Rectangle<int> freqCol = knobRow.removeFromLeft(thirdW);
w.freqValue->setBounds(freqCol.removeFromTop((int)(16*s)));
w.freq->setBounds(freqCol.removeFromTop((int)(48*s)).reduced((int)(colW*0.08f), 0));
w.freqCaption->setBounds(freqCol.removeFromTop((int)(12*s)));
// Q (right half).
w.qValue->setBounds(knobRow.removeFromTop((int)(14*s)));
w.q->setBounds(knobRow.removeFromTop((int)(58*s)).reduced((int)(colW*0.08f), 0));
// Q (right third).
w.qValue->setBounds(knobRow.removeFromTop((int)(16*s)));
w.q->setBounds(knobRow.removeFromTop((int)(48*s)).reduced((int)(colW*0.08f), 0));
w.qCaption->setBounds(knobRow.removeFromTop((int)(12*s)));
}
// Master column.
juce::Rectangle<int> msub = masterArea.reduced((int)(14*s), (int)(6*s));
masterLabel->setBounds(msub.removeFromTop((int) (20 * s)));
masterLabel->setBounds(msub.removeFromTop((int) (22 * s)));
masterPercent->setBounds(msub.removeFromTop((int) (16 * s)));
master->setBounds(msub);
}
void GelykEQAudioProcessorEditor::paint(juce::Graphics& g)
{
const float s = scaling.load();
g.fillAll(lookAndFeel.bg);
g.fillAll(lookAndFeel.bg());
juce::Rectangle<int> area = getLocalBounds();
const int headerH = (int) (46 * s);
@ -426,13 +777,18 @@ void GelykEQAudioProcessorEditor::paint(juce::Graphics& g)
mainArea.removeFromBottom(footerH);
mainArea.removeFromRight((int) (64 * s));
const int topPad = (int) (20 * s);
const int botPad = (int) (28 * s);
const float topY = (float) (mainArea.getY() + topPad);
const float botY = (float) (mainArea.getY() + mainArea.getHeight() - botPad);
// The visualizer is the gain-fader field, bounded above by the header controls
// and below by the LEVEL/FREQ/Q knob row. Keep the waveform/spectrum and grid
// strictly inside it so they don't spill over the knobs.
const float captionH = 20.0f * s;
const float valueH = 17.0f * s;
const float freqH = 23.0f * s;
const float knobStackH = (16.0f + 48.0f + 12.0f) * s;
const float topY = (float) mainArea.getY() + captionH + valueH;
const float botY = (float) mainArea.getBottom() - freqH - knobStackH - 6.0f * s;
// Neon grid lines.
g.setColour(lookAndFeel.line);
g.setColour(lookAndFeel.line());
for (int i = 1; i <= 4; ++i)
{
if (i == 3) continue; // skip the 0 dB centre (drawn separately)
@ -442,21 +798,27 @@ void GelykEQAudioProcessorEditor::paint(juce::Graphics& g)
// 0 dB centre line (glowing cyan).
const float centreLineY = topY + (botY - topY) * 0.5f;
g.setColour(lookAndFeel.cyan.withAlpha(0.55f));
g.setColour(lookAndFeel.cyan().withAlpha(0.55f));
g.drawHorizontalLine((int) centreLineY, (float) mainArea.getX(), (float) mainArea.getRight());
// Spectrum overlay.
if (spectrum.size() > 2)
{
const float waveAlpha = lookAndFeel.waveformOpacity;
const float sensFactor = std::pow(10.0f, lookAndFeel.waveSensitivity / 20.0f);
juce::Path path;
const float x0 = (float) mainArea.getX();
const float width = (float) mainArea.getWidth();
for (int i = 0; i < spectrum.size(); ++i)
{
float db = juce::jlimit(-72.0f, 12.0f, spectrum[i]);
float db = juce::Decibels::gainToDecibels(
juce::Decibels::decibelsToGain(spectrum[i]) * sensFactor);
db = juce::jlimit(-72.0f, 12.0f, db);
float norm = (db + 72.0f) / 84.0f; // 0..1 up
float xx = x0 + (float) i / (float) (spectrum.size() - 1) * width;
float xx = (i < freqBins.size())
? bandFreqToX(freqBins[i], x0, width)
: x0 + (float) i / (float) (spectrum.size() - 1) * width;
float yy = botY - norm * (botY - topY);
if (i == 0) path.startNewSubPath(xx, yy);
else path.lineTo(xx, yy);
@ -467,12 +829,12 @@ void GelykEQAudioProcessorEditor::paint(juce::Graphics& g)
filled.lineTo((float) mainArea.getX(), botY);
filled.closeSubPath();
g.setGradientFill(juce::ColourGradient(lookAndFeel.magenta.withAlpha(0.30f),
g.setGradientFill(juce::ColourGradient(lookAndFeel.magenta().withAlpha(0.30f * waveAlpha),
(float) mainArea.getX(), topY,
lookAndFeel.magenta.withAlpha(0.05f),
lookAndFeel.magenta().withAlpha(0.05f * waveAlpha),
(float) mainArea.getX(), botY, false));
g.fillPath(filled);
g.setColour(lookAndFeel.cyan.withAlpha(0.9f));
g.setColour(lookAndFeel.cyan().withAlpha(0.9f * waveAlpha));
g.strokePath(path, juce::PathStrokeType(1.6f * s));
}
@ -489,18 +851,31 @@ void GelykEQAudioProcessorEditor::paint(juce::Graphics& g)
{
float db = juce::jlimit(-24.0f, 24.0f, eqCurve[i]);
float yy = centreY - (db / 24.0f) * halfH;
float xx = x0 + (float) i / (float) (eqCurve.size() - 1) * width;
// eqCurve bins are log-spaced from 20 Hz to 20 kHz; use the same
// log-frequency mapping as the columns so peaks line up with bands.
const float f = 20.0f * std::pow(1000.0f, (float) i / (float) (eqCurve.size() - 1));
float xx = bandFreqToX(f, x0, width);
if (i == 0) curve.startNewSubPath(xx, yy);
else curve.lineTo(xx, yy);
}
g.setColour(lookAndFeel.violet.withAlpha(0.20f));
g.setColour(lookAndFeel.violet().withAlpha(0.20f));
g.strokePath(curve, juce::PathStrokeType(7.0f * s, juce::PathStrokeType::curved,
juce::PathStrokeType::rounded));
g.setColour(lookAndFeel.violet);
g.setColour(lookAndFeel.violet());
g.strokePath(curve, juce::PathStrokeType(1.8f * s, juce::PathStrokeType::curved,
juce::PathStrokeType::rounded));
}
// Very light rounded outline around each band's knob group (LEVEL/FREQ/Q).
g.setColour(lookAndFeel.line());
const float corner = 6.0f * s;
const float inset = 2.0f * s;
for (int i = 0; i < numBands; ++i)
{
juce::Rectangle<float> r = bandSections[i].reduced(inset);
g.drawRoundedRectangle(r, corner, 1.0f * s);
}
}
} // namespace gelyk