plugin_descriptor.hpp

Go to the documentation of this file.

#pragma once
 
// Static plugin metadata: the descriptor a Processor returns once at
// initialization, plus the bus, category, capability, and editor-size types it
// is built from. processor.hpp includes this header, so existing consumers keep
// compiling unchanged; new code should include it directly.
 
#include <cstdint>
#include <pulp/format/bus_role.hpp>
#include <string>
#include <vector>
 
namespace pulp::format {

enum class ViewportPolicy : uint8_t {
    Automatic,
    FixedDesign,
    Responsive,
};

struct ViewSize {
    uint32_t preferred_width = 400;
    uint32_t preferred_height = 300;
    uint32_t min_width = 0;
    uint32_t min_height = 0;
    uint32_t max_width = 0;   
    uint32_t max_height = 0;  

    double aspect_ratio = 0.0;

    uint32_t design_width = 0;
    uint32_t design_height = 0;

    ViewportPolicy viewport_policy = ViewportPolicy::Automatic;
};
 
constexpr uint32_t design_viewport_width(const ViewSize& hints) {
    return hints.design_width > 0 ? hints.design_width : hints.preferred_width;
}
 
constexpr uint32_t design_viewport_height(const ViewSize& hints) {
    return hints.design_height > 0 ? hints.design_height : hints.preferred_height;
}

constexpr ViewSize view_size_from_design(uint32_t preferred_width,
                                          uint32_t preferred_height,
                                          uint32_t min_width = 0,
                                          uint32_t min_height = 0,
                                          uint32_t max_width = 0,
                                          uint32_t max_height = 0) {
    return ViewSize{
        preferred_width,
        preferred_height,
        min_width > 0 ? min_width : (preferred_width * 2) / 3,
        min_height > 0 ? min_height : (preferred_height * 2) / 3,
        max_width > 0 ? max_width : preferred_width * 2,
        max_height > 0 ? max_height : preferred_height * 2,
        preferred_height > 0
            ? static_cast<double>(preferred_width) / static_cast<double>(preferred_height)
            : 0.0,
    };
}

constexpr bool should_pin_design_viewport(const ViewSize& hints) {
    if (hints.viewport_policy == ViewportPolicy::Responsive) return false;
    if (hints.viewport_policy == ViewportPolicy::FixedDesign) {
        return design_viewport_width(hints) > 0 &&
               design_viewport_height(hints) > 0;
    }
    const bool resizable = hints.min_width > 0 && hints.min_height > 0;
    const bool free_resize = resizable && hints.aspect_ratio <= 0.0;
    return hints.preferred_width > 0 && hints.preferred_height > 0 && !free_resize;
}

constexpr bool should_lock_view_aspect(const ViewSize& hints) {
    return hints.aspect_ratio > 0.0;
}

constexpr double native_view_aspect_ratio(const ViewSize& hints) {
    if (should_lock_view_aspect(hints)) return hints.aspect_ratio;
    if (!should_pin_design_viewport(hints)) return 0.0;
    const auto width = design_viewport_width(hints);
    const auto height = design_viewport_height(hints);
    return width > 0 && height > 0
        ? static_cast<double>(width) / static_cast<double>(height)
        : 0.0;
}

template <typename NativeHost>
void configure_native_viewport(NativeHost& host, const ViewSize& hints) {
    if (should_pin_design_viewport(hints)) {
        host.set_design_viewport(
            static_cast<float>(design_viewport_width(hints)),
            static_cast<float>(design_viewport_height(hints)));
    }
    const double aspect_ratio = native_view_aspect_ratio(hints);
    if (aspect_ratio > 0.0) {
        host.set_fixed_aspect_ratio(static_cast<float>(aspect_ratio));
    }
}

template <typename NativeHost>
void commit_editor_requested_viewport(NativeHost& host,
                                      const ViewSize& hints,
                                      uint32_t width,
                                      uint32_t height) {
    if (should_pin_design_viewport(hints)) {
        const bool has_authored_viewport =
            hints.design_width > 0 && hints.design_height > 0;
        host.set_design_viewport(
            static_cast<float>(has_authored_viewport
                ? design_viewport_width(hints) : width),
            static_cast<float>(has_authored_viewport
                ? design_viewport_height(hints) : height));
    }
    const double aspect_ratio = should_lock_view_aspect(hints)
        ? hints.aspect_ratio
        : (should_pin_design_viewport(hints) && height > 0
            ? static_cast<double>(width) / static_cast<double>(height)
            : 0.0);
    if (aspect_ratio > 0.0) {
        host.set_fixed_aspect_ratio(static_cast<float>(aspect_ratio));
    }
}

enum class PluginCategory {
    Effect,      
    Instrument,  
    MidiEffect,  
};

struct BusInfo {
    std::string name;
    int default_channels = 2;
    bool optional = false;  
    BusRole role = BusRole::Main;
};

struct BusLayoutConfiguration {
    std::vector<int> inputs;
    std::vector<int> outputs;
    std::string name;
};

struct NodeCapabilities {
    bool supports_mpe = false;
    bool supports_ump = false;
    bool supports_f64_audio = false;
    bool consumes_audio_rate_modulations = false;
    bool writes_input_buffers = false;
};

struct PluginDescriptor {
    std::string name;
    std::string manufacturer;
    std::string bundle_id;
    std::string version;       
    PluginCategory category = PluginCategory::Effect;

    std::vector<BusInfo> input_buses = {{"Main In", 2, false}};
    std::vector<BusInfo> output_buses = {{"Main Out", 2, false}};
 
    bool accepts_midi = false;   
    bool produces_midi = false;  

    bool supports_mpe = false;

    bool supports_ump = false;

    bool ios_requires_background_audio = false;

    int tail_samples = 0;

    std::string vendor_url;
    std::string vendor_email;

    NodeCapabilities node_capabilities;

    bool supports_f64_audio = false;

    std::vector<BusLayoutConfiguration> supported_bus_layouts;

    std::uint32_t voice_count = 0;
 
    NodeCapabilities effective_capabilities() const {
        return {
            .supports_mpe = supports_mpe || node_capabilities.supports_mpe,
            .supports_ump = supports_ump || node_capabilities.supports_ump,
            .supports_f64_audio = supports_f64_audio || node_capabilities.supports_f64_audio,
            .consumes_audio_rate_modulations = node_capabilities.consumes_audio_rate_modulations,
            .writes_input_buffers = node_capabilities.writes_input_buffers,
        };
    }

    int default_input_channels() const {
        return input_buses.empty() ? 0 : input_buses[0].default_channels;
    }

    int default_output_channels() const {
        return output_buses.empty() ? 0 : output_buses[0].default_channels;
    }
};
 
} // namespace pulp::format