init

Source/VectorScope.cpp

@@ -0,0 +1,198 @@
+#include "VectorScope.h"
+
+VectorScope::VectorScope(TerionProcessor& p)
+    : processor(p)
+{
+    startTimerHz(30);
+}
+
+VectorScope::~VectorScope()
+{
+    stopTimer();
+}
+
+void VectorScope::timerCallback()
+{
+    repaint();
+}
+
+float VectorScope::getRadius() const
+{
+    auto bounds = getLocalBounds();
+    return juce::jmin(bounds.getWidth(), bounds.getHeight()) * 0.5f * 0.85f;
+}
+
+void VectorScope::resized()
+{
+    auto bounds = getLocalBounds();
+    trail = juce::Image(juce::Image::ARGB, bounds.getWidth(), bounds.getHeight(), true);
+}
+
+void VectorScope::paint(juce::Graphics& g)
+{
+    auto bounds = getLocalBounds();
+    const int w = bounds.getWidth();
+    const int h = bounds.getHeight();
+    const float cx = w * 0.5f;
+    const float cy = h * 0.5f;
+    const float radius = getRadius();
+    const float dotSize = processor.apvts.getRawParameterValue("dotSize")->load();
+    const float frozen = processor.apvts.getRawParameterValue("freeze")->load();
+
+    // Rebuild the trail from live points each frame (only if not frozen).
+    // The trail is fully cleared first, then every point with age < fadeTime
+    // is redrawn with its age-based alpha, so dots past fadeTime disappear
+    // completely instead of leaving an asymptotic dark-grey residue.
+    if (trail.isValid() && frozen < 0.5f)
+    {
+        juce::Graphics trailG(trail);
+        trailG.setColour(juce::Colours::black);
+        trailG.fillRect(trail.getBounds().toFloat());
+
+        const auto& points = processor.getPoints();
+        const float fadeTime = processor.apvts.getRawParameterValue("fadeTime")->load();
+
+        for (const auto& pt : points)
+        {
+            if (pt.age > fadeTime)
+                continue;
+
+            float normAge = pt.age / fadeTime;
+            float alpha = 1.0f - normAge;
+            alpha = alpha * alpha;
+
+            float x = cx + pt.side * radius * 2.0f;
+            float y = cy - pt.mid * radius * 2.0f;
+
+            float phase = std::abs(pt.side) / (std::abs(pt.mid) + 0.0001f);
+            phase = juce::jmin(phase, 1.0f);
+
+            juce::Colour color = juce::Colour::fromFloatRGBA(
+                0.2f + phase * 0.8f,
+                1.0f - phase * 0.4f,
+                1.0f - phase * 0.6f,
+                alpha * 0.9f);
+
+            trailG.setColour(color);
+            trailG.fillRect(x - dotSize * 0.5f, y - dotSize * 0.5f, dotSize, dotSize);
+        }
+    }
+
+    // Draw background
+    g.fillAll(juce::Colour(0xff0a0a0f));
+
+    // Draw the trail
+    if (trail.isValid())
+        g.drawImageAt(trail, 0, 0);
+
+    // Concentric circles with dB labels
+    g.setColour(juce::Colour(0xff1a1a25));
+    const float dBValues[] = { -12.0f, -6.0f, 0.0f };
+    const float dBFactors[] = { 0.25f, 0.5f, 1.0f };
+    for (int i = 0; i < 3; ++i)
+    {
+        float r = radius * dBFactors[i];
+        g.drawEllipse(cx - r, cy - r, r * 2.0f, r * 2.0f, 0.5f);
+
+        // dB label at top-right of each circle
+        g.setColour(juce::Colour(0xff444455));
+        g.setFont(9.0f);
+        juce::String dbLabel = juce::String(dBValues[i], 0) + "dB";
+        g.drawText(dbLabel, cx + r + 3, cy - r - 2, 40, 14, juce::Justification::centredLeft);
+        g.setColour(juce::Colour(0xff1a1a25));
+    }
+
+    // 45-degree lines (L=R and L=-R)
+    g.setColour(juce::Colour(0xff181822));
+    g.drawLine(cx - radius, cy - radius, cx + radius, cy + radius, 0.5f);
+    g.drawLine(cx - radius, cy + radius, cx + radius, cy - radius, 0.5f);
+
+    // Hair cross (brighter, thin)
+    drawHairCross(g, cx, cy);
+
+    // Legends
+    drawLegends(g, cx, cy, radius);
+
+    // Metrics overlay
+    drawMetricsOverlay(g, bounds);
+
+    // Border
+    g.setColour(juce::Colour(0xff333340));
+    g.drawRect(bounds, 1);
+}
+
+void VectorScope::drawHairCross(juce::Graphics& g, float cx, float cy)
+{
+    auto bounds = getLocalBounds().toFloat();
+
+    // Bright center cross — two short, bright strokes
+    g.setColour(juce::Colour(0xff666680));
+
+    // Horizontal
+    g.drawLine(bounds.getX() + 8.0f, cy, bounds.getRight() - 8.0f, cy, 0.5f);
+    // Vertical
+    g.drawLine(cx, bounds.getY() + 8.0f, cx, bounds.getBottom() - 8.0f, 0.5f);
+
+    // Tiny center dot
+    g.setColour(juce::Colour(0xff8888aa));
+    g.fillEllipse(cx - 2.0f, cy - 2.0f, 4.0f, 4.0f);
+}
+
+void VectorScope::drawLegends(juce::Graphics& g, float cx, float cy, float radius)
+{
+    g.setColour(juce::Colour(0xff666677));
+    g.setFont(10.0f);
+
+    // Side label (X axis, right side)
+    g.drawText("Side", cx + radius + 4.0f, cy + 4.0f, 40, 14, juce::Justification::centredLeft);
+
+    // Mid label (Y axis, top)
+    g.drawText("Mid", cx + 4.0f, cy - radius - 16.0f, 40, 14, juce::Justification::centredLeft);
+
+    // Diagonal labels: in M/S space these are the pure-channel loci
+    g.setColour(juce::Colour(0xff444455));
+    g.setFont(8.0f);
+
+    // L = 0 (right channel only): line y = x through centre
+    float diagX = cx + radius * 0.71f;
+    g.drawText("R only", diagX + 4.0f, cy + radius * 0.71f, 30, 12, juce::Justification::centredLeft);
+
+    // R = 0 (left channel only): line y = -x through centre
+    g.drawText("L only", diagX + 4.0f, cy - radius * 0.71f - 12.0f, 30, 12, juce::Justification::centredLeft);
+}
+
+void VectorScope::drawMetricsOverlay(juce::Graphics& g, const juce::Rectangle<int>& bounds)
+{
+    const auto& metrics = processor.getMetrics();
+    const int margin = 10;
+    const int lineHeight = 14;
+    const int startY = bounds.getBottom() - margin - (7 * lineHeight);
+
+    // Background panel
+    juce::Rectangle<int> panelRect(bounds.getX() + margin, startY - 5, 120, 7 * lineHeight + 10);
+    g.setColour(juce::Colour(0xff0a0a0f).withAlpha(0.8f));
+    g.fillRect(panelRect);
+    g.setColour(juce::Colour(0xff333340));
+    g.drawRect(panelRect, 1);
+
+    // Metrics text
+    g.setFont(9.0f);
+    g.setColour(juce::Colour(0xff888899));
+
+    auto drawMetric = [&](const juce::String& label, float value, const juce::String& unit, int y)
+    {
+        g.drawText(label, panelRect.getX() + 5, y, 50, lineHeight, juce::Justification::centredLeft);
+        g.setColour(juce::Colour(0xffccccdd));
+        g.drawText(juce::String(value, 1) + unit, panelRect.getX() + 55, y, 60, lineHeight, juce::Justification::centredRight);
+        g.setColour(juce::Colour(0xff888899));
+    };
+
+    int y = startY;
+    drawMetric("Corr", metrics.correlation, "", y); y += lineHeight;
+    drawMetric("Width", metrics.stereoWidth, "dB", y); y += lineHeight;
+    drawMetric("Mid", metrics.midLevel, "dB", y); y += lineHeight;
+    drawMetric("Side", metrics.sideLevel, "dB", y); y += lineHeight;
+    drawMetric("Balance", metrics.balance, "dB", y); y += lineHeight;
+    drawMetric("Phase", metrics.phaseAngle, "\u00B0", y); y += lineHeight;
+    drawMetric("Crest", metrics.crestFactor, "dB", y); y += lineHeight;
+}