region_renderer.h

// SPDX-FileCopyrightText: © 2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "structure/arrangement/arranger_object_all.h"
#include "utils/units.h"
 
#include <juce_wrapper.h>
 
namespace zrythm::structure::arrangement
{

class RegionRenderer final
{
public:
  static void serialize_to_sequence (
    const MidiRegion          &region,
    juce::MidiMessageSequence &events,
    std::optional<std::pair<double, double>> timeline_range_ticks = std::nullopt);

  static void serialize_to_sequence (
    const ChordRegion         &region,
    juce::MidiMessageSequence &events,
    std::optional<std::pair<double, double>> timeline_range_ticks = std::nullopt);

  static void serialize_to_buffer (
    const AudioRegion       &region,
    juce::AudioSampleBuffer &buffer,
    std::optional<std::pair<double, double>> timeline_range_ticks = std::nullopt);

  static void serialize_to_automation_values (
    const AutomationRegion &region,
    std::vector<float>     &values,
    std::optional<std::pair<double, double>> timeline_range_ticks = std::nullopt)
    [[clang::blocking]];
 
private:
  struct LoopParameters
  {
    units::precise_tick_t loop_start;
    units::precise_tick_t loop_end;
    units::precise_tick_t clip_start;
    units::precise_tick_t loop_length;
    units::precise_tick_t region_length;
    int                   num_loops;
 
    LoopParameters (const ArrangerObject &region);
  };
 
  template <RegionObject RegionT, typename EventsT>
  static void serialize_region (
    const RegionT &region,
    EventsT       &events,
    // currently unused
    std::optional<std::pair<double, double>> timeline_range_ticks = std::nullopt)
  {
    const auto * loop_range = region.loopRange ();
    const auto   loop_length = loop_range->get_loop_length_in_ticks ();
    const auto   region_length =
      units::ticks (region.bounds ()->length ()->ticks ());
 
    auto loop_segment_virtual_start =
      units::ticks (loop_range->clipStartPosition ()->ticks ());
    auto loop_segment_virtual_end =
      units::ticks (loop_range->loopEndPosition ()->ticks ());
    auto loop_segment_absolute_start = units::ticks (0.0);
    auto loop_segment_absolute_end =
      loop_segment_virtual_end - loop_segment_virtual_start;
    if (loop_segment_absolute_end > region_length)
      {
        const auto delta = loop_segment_absolute_end - region_length;
        loop_segment_virtual_end -= delta;
        loop_segment_absolute_end -= delta;
      }
 
    while (loop_segment_absolute_start < region_length)
      {
        if constexpr (std::is_same_v<RegionT, MidiRegion>)
          {
            handle_midi_region_range (
              region, events,
              std::make_pair (
                loop_segment_virtual_start, loop_segment_virtual_end),
              loop_segment_absolute_start);
          }
        else if constexpr (std::is_same_v<RegionT, ChordRegion>)
          {
            handle_chord_region_range (
              region, events,
              std::make_pair (
                loop_segment_virtual_start, loop_segment_virtual_end),
              loop_segment_absolute_start);
          }
        else if constexpr (std::is_same_v<RegionT, AudioRegion>)
          {
            handle_audio_region_range (
              region, events,
              std::make_pair (
                loop_segment_virtual_start, loop_segment_virtual_end),
              loop_segment_absolute_start);
          }
        else if constexpr (std::is_same_v<RegionT, AutomationRegion>)
          {
            handle_automation_region_range (
              region, events,
              std::make_pair (
                loop_segment_virtual_start, loop_segment_virtual_end),
              loop_segment_absolute_start);
          }
 
        // Advance to next segment
        const auto currentLen =
          loop_segment_absolute_end - loop_segment_absolute_start;
        loop_segment_virtual_start =
          units::ticks (loop_range->loopStartPosition ()->ticks ());
        loop_segment_virtual_end =
          units::ticks (loop_range->loopEndPosition ()->ticks ());
        loop_segment_absolute_start += currentLen;
        loop_segment_absolute_end += loop_length;
 
        // Clip final segment to region bounds
        if (loop_segment_absolute_end > region_length)
          {
            const auto delta = loop_segment_absolute_end - region_length;
            loop_segment_virtual_end -= delta;
            loop_segment_absolute_end -= delta;
          }
      }
  }
 
  static void handle_midi_region_range (
    const MidiRegion                                       &region,
    juce::MidiMessageSequence                              &events,
    std::pair<units::precise_tick_t, units::precise_tick_t> virtual_range,
    units::precise_tick_t                                   absolute_start);
 
  static void handle_chord_region_range (
    const ChordRegion                                      &region,
    juce::MidiMessageSequence                              &events,
    std::pair<units::precise_tick_t, units::precise_tick_t> virtual_range,
    units::precise_tick_t                                   absolute_start);
 
  static void handle_audio_region_range (
    const AudioRegion                                      &region,
    juce::AudioSampleBuffer                                &buffer,
    std::pair<units::precise_tick_t, units::precise_tick_t> virtual_range,
    units::precise_tick_t                                   absolute_start);
 
  static void handle_automation_region_range (
    const AutomationRegion                                 &region,
    std::vector<float>                                     &values,
    std::pair<units::precise_tick_t, units::precise_tick_t> virtual_range,
    units::precise_tick_t                                   absolute_start);

  static void
  apply_gain_pass (const AudioRegion &region, juce::AudioSampleBuffer &buffer);

  static void apply_region_fades_pass (
    const AudioRegion       &region,
    juce::AudioSampleBuffer &buffer);

  static void apply_builtin_fades_pass (
    const AudioRegion       &region,
    juce::AudioSampleBuffer &buffer,
    int                      builtin_fade_frames);
};
 
} // namespace zrythm::structure::arrangement