Struct IntParam 

pub struct IntParam {
    pub smoothed: Smoother<i32>,
    /* private fields */
}

A discrete integer parameter that’s stored unnormalized. The range is used for the normalization process.

Fields

smoothed: Smoother<i32>

An optional smoother that will automatically interpolate between the new automation values set by the host.

Implementations

impl IntParam

pub fn new(name: impl Into<String>, default: i32, range: IntRange) -> Self

Build a new IntParam. Use the other associated functions to modify the behavior of the parameter.

pub fn value(&self) -> i32

The field’s current plain value, after monophonic modulation has been applied. Equivalent to calling param.plain_value().

pub fn range(&self) -> IntRange

The range of valid plain values for this parameter.

pub fn with_poly_modulation_id(self, id: u32) -> Self

Enable polyphonic modulation for this parameter. The ID is used to uniquely identify this parameter in NoteEvent::PolyModulation events, and must thus be unique between all polyphonically modulatable parameters. See the event’s documentation on how to use polyphonic modulation. Also consider configuring the ClapPlugin::CLAP_POLY_MODULATION_CONFIG constant when enabling this.

Important

After enabling polyphonic modulation, the plugin must start sending NoteEvent::VoiceTerminated events to the host when a voice has fully ended. This allows the host to reuse its modulation resources.

pub fn with_smoother(self, style: SmoothingStyle) -> Self

Set up a smoother that can gradually interpolate changes made to this parameter, preventing clicks and zipper noises.

pub fn with_callback(self, callback: Arc<dyn Fn(i32) + Send + Sync>) -> Self

Run a callback whenever this parameter’s value changes. The argument passed to this function is the parameter’s new value. This should not do anything expensive as it may be called multiple times in rapid succession, and it can be run from both the GUI and the audio thread.

pub fn with_unit(self, unit: &'static str) -> Self

Display a unit when rendering this parameter to a string. Appended after the value_to_string function if that is also set. nice-plug will not automatically add a space before the unit.

pub fn with_value_to_string( self, callback: Arc<dyn Fn(i32) -> String + Send + Sync>, ) -> Self

Use a custom conversion function to convert the plain, unnormalized value to a string.

pub fn with_string_to_value( self, callback: Arc<dyn Fn(&str) -> Option<i32> + Send + Sync>, ) -> Self

Use a custom conversion function to convert from a string to a plain, unnormalized value. If the string cannot be parsed, then this should return a None. If this happens while the parameter is being updated then the update will be canceled.

The input string may or may not contain the unit, so you will need to be able to handle that.

pub fn non_automatable(self) -> Self

Mark the parameter as non-automatable. This means that the parameter cannot be changed from an automation lane. The parameter can however still be manually changed by the user from either the plugin’s own GUI or from the host’s generic UI.

pub fn hide(self) -> Self

Hide the parameter in the host’s generic UI for this plugin. This also implies NON_AUTOMATABLE. Setting this does not prevent you from changing the parameter in the plugin’s editor GUI.

pub fn hide_in_generic_ui(self) -> Self

Don’t show this parameter when generating a generic UI for the plugin using one of nice-plug’s generic UI widgets.

Trait Implementations

impl Debug for IntParam

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for IntParam

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl InternalParamMut for IntParam

unsafe fn _internal_set_plain_value(&self, plain: Self::Plain) -> bool

Set this parameter based on a plain, unnormalized value. This does not snap to step sizes for continuous parameters (i.e. FloatParam). If modulate_value() has previously been called with a non zero value then this offset is taken into account to form the effective value.

unsafe fn _internal_set_normalized_value(&self, normalized: f32) -> bool

Set this parameter based on a normalized value. The normalized value will be snapped to the step size for continuous parameters (i.e. FloatParam). If modulate_value() has previously been called with a non zero value then this offset is taken into account to form the effective value.

unsafe fn _internal_modulate_value(&self, modulation_offset: f32) -> bool

Add a modulation offset to the value’s unmodulated value. This value sticks until this function is called again with a 0.0 value. Out of bound values will be clamped to the parameter’s range. The normalized value will be snapped to the step size for continuous parameters (i.e. FloatParam).

unsafe fn _internal_update_smoother(&self, sample_rate: f32, reset: bool)

Update the smoother state to point to the current value. Also used when initializing and restoring a plugin so everything is in sync. In that case the smoother should completely reset to the current value.

impl Param for IntParam

type Plain = i32

The plain parameter type.

fn name(&self) -> &str

Get the human readable name for this parameter.

fn unit(&self) -> &'static str

Get the unit label for this parameter, if any.

fn poly_modulation_id(&self) -> Option<u32>

Get this parameter’s polyphonic modulation ID. If this is set for a parameter in a CLAP plugin, then polyphonic modulation will be enabled for that parameter. Polyphonic modulation is communicated to the plugin through NoteEvent::PolyModulation and NoteEvent::MonoAutomation events. See the documentation on those events for more information.

fn modulated_plain_value(&self) -> Self::Plain

Get the unnormalized value for this parameter.

fn modulated_normalized_value(&self) -> f32

Get the normalized [0, 1] value for this parameter.

fn unmodulated_plain_value(&self) -> Self::Plain

Get the unnormalized value for this parameter before any (monophonic) modulation coming from the host has been applied. If the host is not currently modulating this parameter than this will be the same as modulated_plain_value(). This may be useful for displaying modulation differently in plugin GUIs. Right now only CLAP plugins in Bitwig Studio use modulation.

fn unmodulated_normalized_value(&self) -> f32

Get the normalized [0, 1] value for this parameter before any (monophonic) modulation coming from the host has been applied. If the host is not currently modulating this parameter than this will be the same as modulated_normalized_value(). This may be useful for displaying modulation differently in plugin GUIs. Right now only CLAP plugins in Bitwig Studio use modulation.

fn default_plain_value(&self) -> Self::Plain

Get the unnormalized default value for this parameter.

fn step_count(&self) -> Option<usize>

Get the number of steps for this parameter, if it is discrete. Used for the host’s generic UI.

fn previous_step(&self, from: Self::Plain, _finer: bool) -> Self::Plain

Returns the previous step from a specific value for this parameter. This can be the same as from if the value is at the start of its range. This is mainly used for scroll wheel interaction in plugin GUIs. When the parameter is not discrete then a step should cover one hundredth of the normalized range instead.

fn next_step(&self, from: Self::Plain, _finer: bool) -> Self::Plain

Returns the next step from a specific value for this parameter. This can be the same as from if the value is at the end of its range. This is mainly used for scroll wheel interaction in plugin GUIs. When the parameter is not discrete then a step should cover one hundredth of the normalized range instead.

fn normalized_value_to_string( &self, normalized: f32, include_unit: bool, ) -> String

Get the string representation for a normalized value. Used as part of the wrappers. Most plugin formats already have support for units, in which case it shouldn’t be part of this string or some DAWs may show duplicate units.

fn string_to_normalized_value(&self, string: &str) -> Option<f32>

Get the string representation for a normalized value. Used as part of the wrappers.

fn preview_normalized(&self, plain: Self::Plain) -> f32

Get the normalized value for a plain, unnormalized value, as a float. Used as part of the wrappers.

fn preview_plain(&self, normalized: f32) -> Self::Plain

Get the plain, unnormalized value for a normalized value, as a float. Used as part of the wrappers. This does snap to step sizes for continuous parameters (i.e. FloatParam).

fn flags(&self) -> ParamFlags

Flags to control the parameter’s behavior. See ParamFlags.

fn as_ptr(&self) -> ParamPtr

Internal implementation detail for implementing Params. This should not be used directly.

fn default_normalized_value(&self) -> f32

Get the normalized [0, 1] default value for this parameter.

fn previous_normalized_step(&self, from: f32, finer: bool) -> f32

The same as previous_step(), but for normalized values. This is mostly useful for GUI widgets.

fn next_normalized_step(&self, from: f32, finer: bool) -> f32

The same as next_step(), but for normalized values. This is mostly useful for GUI widgets.

fn preview_modulated(&self, normalized_offset: f32) -> Self::Plain

Get the plain, unnormalized value for this parameter after polyphonic modulation has been applied. This is a convenience method for calling preview_plain() with unmodulated_normalized_value() + normalized_offset.