automation_point.h

// SPDX-FileCopyrightText: © 2018-2022, 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "dsp/curve.h"
#include "dsp/position.h"
#include "gui/dsp/arranger_object.h"
#include "gui/dsp/bounded_object.h"
#include "gui/dsp/control_port.h"
#include "gui/dsp/region_owned_object.h"
#include "utils/icloneable.h"
#include "utils/math.h"
#include "utils/types.h"
 
class Port;
class AutomationRegion;
class AutomationTrack;
 
using namespace zrythm;


class AutomationPoint final
    : public QObject,
      public RegionOwnedObject,
      public ICloneable<AutomationPoint>
{
  Q_OBJECT
  QML_ELEMENT
  DEFINE_ARRANGER_OBJECT_QML_PROPERTIES (AutomationPoint)
  Q_PROPERTY (double value READ getValue WRITE setValue NOTIFY valueChanged)
public:
  using RegionT = AutomationRegion;
 
  DECLARE_FINAL_ARRANGER_OBJECT_CONSTRUCTORS (AutomationPoint)
  Q_DISABLE_COPY_MOVE (AutomationPoint)
  ~AutomationPoint () override;
 
  // ========================================================================
  // QML Interface
  // ========================================================================
 
  double getValue () const { return fvalue_; }
 
  void setValue (double dval)
  {
    const auto val = static_cast<float> (dval);
    if (!utils::math::floats_equal (fvalue_, val))
      {
        set_fvalue (val, false);
        Q_EMIT valueChanged (dval);
      }
  }
  Q_SIGNAL void valueChanged (double);
 
  // ========================================================================

  void set_fvalue (float real_val, bool is_normalized);

  std::string get_fvalue_as_string () const;

  void set_fvalue_with_action (const std::string &fval_str);

  [[gnu::hot]] double
  get_normalized_value_in_curve (AutomationRegion * region, double x) const;

  void set_curviness (curviness_t curviness);

  ControlPort * get_port () const;

  AutomationTrack * get_automation_track () const;

  bool curves_up () const;
 
  void
  init_after_cloning (const AutomationPoint &other, ObjectCloneType clone_type)
    override;
 
  ArrangerObjectPtrVariant
  add_clone_to_project (bool fire_events) const override;
 
  ArrangerObjectPtrVariant insert_clone_to_project () const override;
 
  bool
  validate (bool is_project, dsp::FramesPerTick frames_per_tick) const override;
 
  friend bool operator< (const AutomationPoint &a, const AutomationPoint &b)
  {
#if 0
  if (a.pos_ == b.pos_) [[unlikely]]
    {
      return a.index_ < b.index_;
    }
#endif
 
    return a.pos_ < b.pos_;
  }
 
  friend bool operator== (const AutomationPoint &a, const AutomationPoint &b)
  {
    /* note: we don't care about the index, only the position and the value */
    /* note2: previously, this code was comparing position ticks, now it only
     * compares frames. TODO: if no problems are caused delete this note */
    return a.pos_ == b.pos_
           && utils::math::floats_near (a.fvalue_, b.fvalue_, 0.001f);
  }
 
private:
  static constexpr std::string_view kValueKey = "value";
  static constexpr std::string_view kNormalizedValueKey = "normalized_value";
  static constexpr std::string_view kCurveOptionsKey = "curve_options";
  friend void to_json (nlohmann::json &j, const AutomationPoint &point)
  {
    to_json (j, static_cast<const ArrangerObject &> (point));
    to_json (j, static_cast<const RegionOwnedObject &> (point));
    j[kValueKey] = point.fvalue_;
    j[kNormalizedValueKey] = point.normalized_val_;
    j[kCurveOptionsKey] = point.curve_opts_;
  }
  friend void from_json (const nlohmann::json &j, AutomationPoint &point)
  {
    from_json (j, static_cast<ArrangerObject &> (point));
    from_json (j, static_cast<RegionOwnedObject &> (point));
    j.at (kValueKey).get_to (point.fvalue_);
    j.at (kNormalizedValueKey).get_to (point.normalized_val_);
    j.at (kCurveOptionsKey).get_to (point.curve_opts_);
  }
 
public:
  float fvalue_ = 0.f;

  float normalized_val_ = 0.f;
 
  dsp::CurveOptions curve_opts_{};
};

enum class AutomationMode
{
  Read,
  Record,
  Off,
  NUM_AUTOMATION_MODES,
};
 
constexpr size_t NUM_AUTOMATION_MODES =
  static_cast<size_t> (AutomationMode::NUM_AUTOMATION_MODES);
 
DEFINE_ENUM_FORMATTER (
  AutomationMode,
  AutomationMode,
  QT_TR_NOOP ("On"),
  QT_TR_NOOP ("Rec"),
  QT_TR_NOOP ("Off"));
 
DEFINE_OBJECT_FORMATTER (
  AutomationPoint,
  AutomationPoint,
  [] (const AutomationPoint &ap) {
    return fmt::format (
      "AutomationPoint [{}]: val {}, normalized val {}", ap.get_position (),
      ap.fvalue_, ap.normalized_val_);
  });