curve.h

// SPDX-FileCopyrightText: © 2020, 2023-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "utils/format.h"
#include "utils/logger.h"
 
#include <QtQmlIntegration>
 
#include <nlohmann/json.hpp>
 
namespace zrythm::dsp
{

class CurveOptions final
{
  Q_GADGET
 
public:
  enum class Algorithm
  {
    Exponent,

    SuperEllipse,

    Vital,

    Pulse,

    Logarithmic,
  };
  Q_ENUM (Algorithm)
 
  
  static constexpr double SUPERELLIPSE_CURVINESS_BOUND = 0.82;
  static constexpr double EXPONENT_CURVINESS_BOUND = 0.95;
  static constexpr double VITAL_CURVINESS_BOUND = 1.00;
 
public:
  // Rule of 0
  CurveOptions () = default;
  CurveOptions (double curviness, Algorithm algo);

  [[gnu::hot]] double get_normalized_y (double x, bool start_higher) const;
 
  friend bool operator== (const CurveOptions &a, const CurveOptions &b);
 
  NLOHMANN_DEFINE_TYPE_INTRUSIVE (CurveOptions, algo_, curviness_)
 
public:
  double curviness_{ 0.0 };

  Algorithm algo_{};
 
  BOOST_DESCRIBE_CLASS (CurveOptions, (), (curviness_, algo_), (), ())
};

class CurveOptionsQmlAdapter : public QObject
{
  Q_OBJECT
  Q_PROPERTY (
    double curviness READ curviness WRITE setCurviness NOTIFY curvinessChanged)
  Q_PROPERTY (
    zrythm::dsp::CurveOptions::Algorithm algorithm READ algorithm WRITE
      setAlgorithm NOTIFY algorithmChanged)
  QML_NAMED_ELEMENT (CurveOptions)
  QML_UNCREATABLE ("")
 
public:
  CurveOptionsQmlAdapter (CurveOptions &options, QObject * parent = nullptr)
      : QObject (parent), options_ (options)
  {
  }
 
  // ========================================================================
  // QML Interface
  // ========================================================================
 
  double curviness () const { return options_.curviness_; }
  void   setCurviness (double curviness)
  {
    if (qFuzzyCompare (options_.curviness_, curviness))
      return;
 
    curviness = std::clamp (curviness, -1.0, 1.0);
    options_.curviness_ = curviness;
    Q_EMIT curvinessChanged (curviness);
  }
  Q_SIGNAL void curvinessChanged (double curviness);
 
  zrythm::dsp::CurveOptions::Algorithm algorithm () const
  {
    return options_.algo_;
  }
  void setAlgorithm (zrythm::dsp::CurveOptions::Algorithm algorithm)
  {
    if (options_.algo_ == algorithm)
      return;
 
    options_.algo_ = algorithm;
    Q_EMIT algorithmChanged (algorithm);
  }
  Q_SIGNAL void
  algorithmChanged (zrythm::dsp::CurveOptions::Algorithm algorithm);
 
  Q_INVOKABLE double normalizedY (double x, bool startHigher) const
  {
    return options_.get_normalized_y (x, startHigher);
  }
 
  // ========================================================================
 
private:
  CurveOptions &options_;
};
 
} // namespace zrythm::dsp
 
DEFINE_ENUM_FORMATTER (
  zrythm::dsp::CurveOptions::Algorithm,
  CurveOptions_Algorithm,
  QT_TR_NOOP_UTF8 ("Exponent"),
  QT_TR_NOOP_UTF8 ("Superellipse"),
  "Vital",
  QT_TR_NOOP_UTF8 ("Pulse"),
  QT_TR_NOOP_UTF8 ("Logarithmic"));