apply_region_transition()

void MayaFlux::Kakshya::RegionOrganizationProcessor::apply_region_transition ( const OrganizedRegion &  current_region, const OrganizedRegion &  next_region, const std::shared_ptr< SignalSourceContainer > &  container, std::vector< DataVariant > &  output_data  )

protectedvirtual

Apply a transition between two regions.

Parameters

current_region	The current region.
next_region	The next region.
container	The signal container.
output_data	Output data variant to fill.

Definition at line 279 of file RegionProcessors.cpp.

{
    if (next_region.segments.empty()) {
        return;
    }
 
    auto next_data = container->get_region_data(next_region.segments[0].source_region);
 
    // TODO:: Reenable when C++23 is more widely supported
    /* for (auto&& [current_var, next_var] : std::views::zip(output_data, next_data)) {
        auto current_span = convert_variant<double>(current_var);
        auto next_span = convert_variant<double>(const_cast<DataVariant&>(next_var));
        auto paired_samples = std::views::zip(current_span, next_span)
            | std::views::enumerate;
 
        switch (current_region.transition_type) {
        case RegionTransition::CROSSFADE:
            std::ranges::for_each(paired_samples, [size = current_span.size()](auto&& item) {
                auto [i, sample_pair] = item;
                auto [current, next] = sample_pair;
                double fade_factor = static_cast<double>(i) / static_cast<double>(size);
                current = current * (1.0 - fade_factor) + next * fade_factor;
            });
            break;
 
        case RegionTransition::OVERLAP:
            std::ranges::for_each(paired_samples, [](auto&& item) {
                auto [i, sample_pair] = item;
                auto [current, next] = sample_pair;
                current = current * 0.5 + next * 0.5;
            });
            break;
 
        default:
            break;
        }
    } */
 
    const size_t data_count = std::min<size_t>(output_data.size(), next_data.size());
    for (size_t variant_idx = 0; variant_idx < data_count; ++variant_idx) {
        auto current_span = convert_variant<double>(output_data[variant_idx]);
        auto next_span = convert_variant<double>(const_cast<DataVariant&>(next_data[variant_idx]));
 
        const size_t sample_count = std::min<size_t>(current_span.size(), next_span.size());
 
        switch (current_region.transition_type) {
        case RegionTransition::CROSSFADE:
            for (size_t i = 0; i < sample_count; ++i) {
                double fade_factor = static_cast<double>(i) / static_cast<double>(sample_count);
                current_span[i] = current_span[i] * (1.0 - fade_factor) + next_span[i] * fade_factor;
            }
            break;
 
        case RegionTransition::OVERLAP:
            for (size_t i = 0; i < sample_count; ++i) {
                current_span[i] = current_span[i] * 0.5 + next_span[i] * 0.5;
            }
            break;
 
        default:
            break;
        }
    }
}

References MayaFlux::Kakshya::CROSSFADE, MayaFlux::Kakshya::OVERLAP, MayaFlux::Kakshya::OrganizedRegion::segments, and MayaFlux::Kakshya::OrganizedRegion::transition_type.

Referenced by process_organized_regions().

Here is the caller graph for this function: