modulation_meter.cpp

Go to the documentation of this file.

#include "modulation_meter.h"
 
#include "open_gl_multi_quad.h"
#include "synth_gui_interface.h"
#include "shaders.h"
#include "synth_section.h"
#include "synth_slider.h"
#include "text_look_and_feel.h"
 
ModulationMeter::ModulationMeter(const vital::Output* mono_total, const vital::Output* poly_total,
                                 const SynthSlider* slider, OpenGlMultiQuad* quads, int index) :
        mono_total_(mono_total), poly_total_(poly_total), destination_(slider),
        quads_(quads), index_(index), current_value_(0.0), mod_percent_(0.0) {
 
  rotary_ = destination_->isRotary() && !destination_->isTextOrCurve();
 
  // If vertical bar or text/curve slider style, rotate coordinates in the multi-quad.
  if (destination_->getSliderStyle() == Slider::LinearBarVertical || destination_->isTextOrCurve())
    quads->setRotatedCoordinates(index, -1.0f, -1.0f, 2.0f, 2.0f);
 
  setInterceptsMouseClicks(false, false);
  updateDrawing(false);
}
 
ModulationMeter::~ModulationMeter() { }
 
void ModulationMeter::resized() {
  SynthGuiInterface* parent = findParentComponentOfClass<SynthGuiInterface>();
  if (parent) {
    // Check if the parameter is modulated by any source.
    std::vector<vital::ModulationConnection*> connections;
    connections = parent->getSynth()->getSourceConnections(getName().toStdString());
    setModulated(!connections.empty());
  }
 
  if (isVisible())
    setVertices();
  else
    collapseVertices();
}
 
void ModulationMeter::setActive(bool active) {
  if (active)
    setVertices();
  else
    collapseVertices();
}
 
Rectangle<float> ModulationMeter::getMeterBounds() {
  float width = getWidth();
  float height = getHeight();
 
  // If not rotary and not text/curve, it's a linear slider: calculate a linear meter area.
  if (!destination_->isRotary() && !destination_->isTextOrCurve()) {
    SynthSection* parent = findParentComponentOfClass<SynthSection>();
    int widget_margin = parent->getWidgetMargin();
 
    int total_width = destination_->isHorizontal() ? destination_->getHeight() : destination_->getWidth();
    int extra = total_width % 2;
    int slider_width = std::floor(SynthSlider::kLinearWidthPercent * total_width * 0.5f) * 2.0f + extra;
 
    int inner_area = (total_width - slider_width) / 2;
    int outer_area = inner_area - widget_margin;
    int meter_width = SynthSlider::kLinearModulationPercent * total_width;
    int border = std::max<int>(1, (widget_margin - meter_width) * 0.5f);
 
    if (destination_->isHorizontal()) {
      // Horizontal slider: meter goes vertically in the slider track.
      return Rectangle<float>(0.0f, outer_area + border, width, inner_area - outer_area - 2.0f * border);
    }
 
    // Vertical slider: meter goes horizontally in the slider track.
    return Rectangle<float>(outer_area + border, 0.0f, inner_area - outer_area - 2.0f * border, height);
  }
  else if (!destination_->isTextOrCurve()) {
    // Rotary knob style
    float knob_scale = destination_->getKnobSizeScale();
    float meter_width = destination_->findValue(Skin::kKnobModMeterArcSize) * knob_scale;
    meter_width += destination_->findValue(Skin::kKnobModMeterArcThickness) * (1.0f - knob_scale);
    float offset = destination_->findValue(Skin::kKnobOffset);
 
    float center_x = getWidth() * 0.5f;
    float center_y = getHeight() * 0.5f;
    return Rectangle<float>(center_x - meter_width * 0.5f, center_y - meter_width * 0.5f + offset,
                            meter_width, meter_width);
  }
 
  // For text or curve style, use the entire area.
  return getLocalBounds().toFloat();
}
 
void ModulationMeter::setVertices() {
  Rectangle<int> parent_bounds = getParentComponent()->getBounds();
  Rectangle<int> bounds = getBounds();
  Rectangle<float> meter_bounds = getMeterBounds();
  float left = bounds.getX() + meter_bounds.getX();
  float right = bounds.getX() + meter_bounds.getRight();
  float top = parent_bounds.getHeight() - (bounds.getY() + meter_bounds.getY());
  float bottom = parent_bounds.getHeight() - (bounds.getY() + meter_bounds.getBottom());
 
  left_ = 2.0f * left / parent_bounds.getWidth() - 1.0f;
  right_ = 2.0f * right / parent_bounds.getWidth() - 1.0f;
  top_ = 2.0f * top / parent_bounds.getHeight() - 1.0f;
  bottom_ = 2.0f * bottom / parent_bounds.getHeight() - 1.0f;
  quads_->setQuad(index_, left_, bottom_, right_ - left_, top_ - bottom_);
}
 
void ModulationMeter::collapseVertices() {
  left_ = right_ = top_ = bottom_= 0.0f;
 
  quads_->setQuad(index_, left_, bottom_, right_ - left_, top_ - bottom_);
  mod_percent_ = 0.0f;
}
 
void ModulationMeter::setAmountQuadVertices(OpenGlQuad& quad) {
  Rectangle<float> meter_bounds = getMeterBounds();
  if (rotary_)
    meter_bounds.expand(2.0f, 2.0f);
 
  float width = getWidth();
  float height = getHeight();
  float left = 2.0f * meter_bounds.getX() / width - 1.0f;
  float bottom = 1.0f - 2.0f * meter_bounds.getBottom() / height;
 
  bool vertical_bar = destination_->getSliderStyle() == Slider::LinearBarVertical || destination_->isTextOrCurve();
  if (vertical_bar)
    quad.setRotatedCoordinates(0, -1.0f, -1.0f, 2.0f, 2.0f);
  else
    quad.setCoordinates(0, -1.0f, -1.0f, 2.0f, 2.0f);
 
  if (rotary_)
    quad.setQuad(0, left, bottom, 2.0f * meter_bounds.getWidth() / width, 2.0f * meter_bounds.getHeight() / height);
  else if (vertical_bar) {
    float thickness = 2.0f / width;
    quad.setQuad(0, left, bottom, thickness, 2.0f * meter_bounds.getHeight() / height);
  }
  else {
    float thickness = 2.0f / height;
    quad.setQuad(0, left, bottom + 2.0f * meter_bounds.getHeight() / height - thickness,
                 2.0f * meter_bounds.getWidth() / width, thickness);
  }
}
 
void ModulationMeter::updateDrawing(bool use_poly) {
  if (mono_total_) {
    current_value_ = mono_total_->trigger_value;
    if (poly_total_ && use_poly)
      current_value_ += poly_total_->trigger_value;
  }
 
  float range = destination_->getMaximum() - destination_->getMinimum();
  vital::poly_float value = (current_value_ - destination_->getMinimum()) * (1.0f / range);
  mod_percent_ = vital::utils::clamp(value, 0.0f, 1.0f);
  float knob_percent = (destination_->getValue() - destination_->getMinimum()) / range;
 
  vital::poly_float min_percent = vital::utils::min(mod_percent_, knob_percent);
  vital::poly_float max_percent = vital::utils::max(mod_percent_, knob_percent);
 
  quads_->setQuad(index_, left_, bottom_, right_ - left_, top_ - bottom_);
 
  // Convert to angles if rotary
  if (rotary_) {
    if (&destination_->getLookAndFeel() == TextLookAndFeel::instance()) {
      min_percent = vital::utils::interpolate(-vital::kPi, 0.0f, min_percent);
      max_percent = vital::utils::interpolate(-vital::kPi, 0.0f, max_percent);
    }
    else {
      float angle = SynthSlider::kRotaryAngle;
      min_percent = vital::utils::interpolate(-angle, angle, min_percent);
      max_percent = vital::utils::interpolate(-angle, angle, max_percent);
    }
  }
 
  quads_->setShaderValue(index_, min_percent[0], 0);
  quads_->setShaderValue(index_, max_percent[0], 1);
  quads_->setShaderValue(index_, min_percent[1], 2);
  quads_->setShaderValue(index_, max_percent[1], 3);
}
 
void ModulationMeter::setModulationAmountQuad(OpenGlQuad& quad, float amount, bool bipolar) {
  float range = destination_->getMaximum() - destination_->getMinimum();
  float knob_percent = (destination_->getValue() - destination_->getMinimum()) / range;
 
  float min_percent = std::min(knob_percent + amount, knob_percent);
  float max_percent = std::max(knob_percent + amount, knob_percent);
  if (bipolar) {
    min_percent = std::min(knob_percent + amount * 0.5f, knob_percent - amount * 0.5f);
    max_percent = std::max(knob_percent + amount * 0.5f, knob_percent - amount * 0.5f);
  }
 
  // Convert to angles if rotary
  if (rotary_) {
    if (&destination_->getLookAndFeel() == TextLookAndFeel::instance()) {
      min_percent = vital::utils::interpolate(-vital::kPi, 0.0f, min_percent);
      max_percent = vital::utils::interpolate(-vital::kPi, 0.0f, max_percent);
    }
    else {
      float angle = SynthSlider::kRotaryAngle;
      min_percent = vital::utils::interpolate(-angle, angle, min_percent);
      max_percent = vital::utils::interpolate(-angle, angle, max_percent);
      min_percent = std::max(-angle, min_percent);
      max_percent = std::min(angle, max_percent);
    }
  }
 
  quad.setShaderValue(0, min_percent, 0);
  quad.setShaderValue(0, max_percent, 1);
  quad.setShaderValue(0, min_percent, 2);
  quad.setShaderValue(0, max_percent, 3);
}