chord_descriptor.h

// SPDX-FileCopyrightText: © 2018-2022, 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "utils/utf8_string.h"
 
#include <nlohmann/json.hpp>
 
namespace zrythm::dsp
{
Q_NAMESPACE
 
enum class MusicalNote : std::uint8_t
{
  C = 0,
  CSharp,
  D,
  DSharp,
  E,
  F,
  FSharp,
  G,
  GSharp,
  A,
  ASharp,
  B
};
Q_ENUM_NS (MusicalNote)
 

enum class ChordType : std::uint8_t
{
  None,
  Major,
  Minor,
  Diminished,
  SuspendedFourth,
  SuspendedSecond,
  Augmented,
  Custom,
};
Q_ENUM_NS (ChordType)
 

enum class ChordAccent : std::uint8_t
{
  None,
  Seventh,
  MajorSeventh,
  /* NOTE: all accents below assume Seventh */
  FlatNinth,
  Ninth,
  SharpNinth,
  Eleventh,
  FlatFifthSharpEleventh,
  SharpFifthFlatThirteenth,
  SixthThirteenth,
};
Q_ENUM_NS (ChordAccent)
 

class ChordDescriptor
{
public:
  static constexpr size_t MAX_NOTES = 48;
 
public:
  ChordDescriptor () = default;

  ChordDescriptor (
    MusicalNote root,
    bool        has_bass,
    MusicalNote bass,
    ChordType   type,
    ChordAccent accent,
    int         inversion)
      : has_bass_ (has_bass), root_note_ (root), bass_note_ (bass),
        type_ (type), accent_ (accent), inversion_ (inversion)
  {
    update_notes ();
  }
 
  int get_max_inversion () const
  {
    int max_inv = 2;
    switch (accent_)
      {
      case ChordAccent::None:
        break;
      case ChordAccent::Seventh:
      case ChordAccent::MajorSeventh:
      case ChordAccent::FlatNinth:
      case ChordAccent::Ninth:
      case ChordAccent::SharpNinth:
      case ChordAccent::Eleventh:
        max_inv = 3;
        break;
      case ChordAccent::FlatFifthSharpEleventh:
      case ChordAccent::SharpFifthFlatThirteenth:
      case ChordAccent::SixthThirteenth:
        max_inv = 4;
        break;
      default:
        break;
      }
 
    return max_inv;
  }
 
  int get_min_inversion () const { return -get_max_inversion (); }

  bool is_key_in_chord (MusicalNote key) const;

  bool is_key_bass (MusicalNote key) const;

  static utils::Utf8String chord_type_to_string (ChordType type);

  static utils::Utf8String chord_accent_to_string (ChordAccent accent);

  static utils::Utf8String note_to_string (MusicalNote note);

  utils::Utf8String to_string () const;

  void update_notes ();
 
  friend bool
  operator== (const ChordDescriptor &lhs, const ChordDescriptor &rhs)
  {
    return lhs.has_bass_ == rhs.has_bass_ && lhs.root_note_ == rhs.root_note_
           && lhs.bass_note_ == rhs.bass_note_ && lhs.type_ == rhs.type_
           && lhs.notes_ == rhs.notes_ && lhs.inversion_ == rhs.inversion_;
  }
 
  NLOHMANN_DEFINE_TYPE_INTRUSIVE (
    ChordDescriptor,
    has_bass_,
    root_note_,
    bass_note_,
    type_,
    accent_,
    notes_,
    inversion_)
 
public:
  bool has_bass_ = false;

  MusicalNote root_note_ = MusicalNote::C;

  MusicalNote bass_note_ = MusicalNote::C;

  ChordType type_ = ChordType::None;

  ChordAccent accent_ = ChordAccent::None;

  std::array<bool, MAX_NOTES> notes_{};

  int inversion_ = 0;
};
 
} // namespace zrythm::dsp