// Copyright (c) 2008-2010 Raynaldo (Wildicv) Rivera, Joshua (Dark_Kilauea) Jones
// This file is part of the "cAudio Engine"
// For conditions of distribution and use, see copyright notice in cAudio.h

#ifndef IEFFECTPARAMETERS_H
#define IEFFECTPARAMETERS_H

#include "cVector3.h"
#include "cAudioDefines.h"

#ifdef CAUDIO_EFX_ENABLED

namespace cAudio
{
//! Contains parameters for the EAX Reverb Effect.  This effect tries to simulate how sound behaves in different environments.
struct sEAXReverbParameters
{
    sEAXReverbParameters(
        float density = 1.0f,
        float diffusion = 1.0f,
        float gain = 0.32f,
        float gainHF = 0.89f,
        float gainLF = 0.0f,
        float decayTime = 1.49f,
        float decayHFRatio = 0.83f,
        float decayLFRatio = 1.0f,
        float reflectionsGain = 0.05f,
        float reflectionsDelay = 0.007f,
        cVector3 reflectionsPan = cVector3(0.0f, 0.0f, 0.0f),
        float lateReverbGain = 1.26f,
        float lateReverbDelay = 0.011f,
        cVector3 lateReverbPan = cVector3(0.0f, 0.0f, 0.0f),
        float echoTime = 0.25f,
        float echoDepth = 0.0f,
        float modulationTime = 0.25f,
        float modulationDepth = 0.0f,
        float airAbsorptionGainHF = 0.994f,
        float hFReference = 5000.0f,
        float lFReference = 250.0f,
        float roomRolloffFactor = 0.0f,
        bool decayHFLimit = true) :
        Density(density), Diffusion(diffusion), Gain(gain), GainHF(gainHF), GainLF(gainLF),
        DecayTime(decayTime), DecayHFRatio(decayHFRatio), DecayLFRatio(decayLFRatio),
        ReflectionsGain(reflectionsGain), ReflectionsDelay(reflectionsDelay),
        ReflectionsPan(reflectionsPan), LateReverbGain(lateReverbGain),
        LateReverbDelay(lateReverbDelay), LateReverbPan(lateReverbPan),
        EchoTime(echoTime), EchoDepth(echoDepth),ModulationTime(modulationTime),
        ModulationDepth(modulationDepth), AirAbsorptionGainHF(airAbsorptionGainHF),
        HFReference(hFReference), LFReference(lFReference),
        RoomRolloffFactor(roomRolloffFactor), DecayHFLimit(decayHFLimit) { }

    //! Reverb Modal Density controls the coloration of the late reverb. Lowering the value adds
    //! more coloration to the late reverb.
    //! Range: 0.0 to 1.0
    float Density;

    //! The Reverb Diffusion property controls the echo density in the reverberation decay. It's set by
    //! default to 1.0, which provides the highest density. Reducing diffusion gives the reverberation a
    //! more "grainy" character that is especially noticeable with percussive sound sources. If you set a
    //! diffusion value of 0.0, the later reverberation sounds like a succession of distinct echoes.
    //! Range: 0.0 to 1.0
    float Diffusion;

    //! The Reverb Gain property is the master volume control for the reflected sound (both early
    //! reflections and reverberation) that the reverb effect adds to all sound sources. It sets the
    //! maximum amount of reflections and reverberation added to the final sound mix. The value of the
    //! Reverb Gain property ranges from 1.0 (0db) (the maximum amount) to 0.0 (-100db) (no reflected
    //! sound at all).
    //! Range: 0.0 to 1.0
    float Gain;

    //! The Reverb Gain HF property further tweaks reflected sound by attenuating it at high frequencies.
    //! It controls a low-pass filter that applies globally to the reflected sound of all sound sources
    //! feeding the particular instance of the reverb effect. The value of the Reverb Gain HF property
    //! ranges from 1.0 (0db) (no filter) to 0.0 (-100db) (virtually no reflected sound). HF Reference sets
    //! the frequency at which the value of this property is measured.
    //! Range: 0.0 to 1.0
    float GainHF;

    //! The Reverb Gain LF property further tweaks reflected sound by attenuating it at low frequencies.
    //! It controls a high-pass filter that applies globally to the reflected sound of all sound sources
    //! feeding the particular instance of the reverb effect. The value of the Reverb Gain LF property
    //! ranges from 1.0 (0db) (no filter) to 0.0 (-100db) (virtually no reflected sound). LF Reference sets
    //! the frequency at which the value of this property is measured.
    //! Range: 0.0 to 1.0
    float GainLF;

    //! The Decay Time property sets the reverberation decay time. It ranges from 0.1 (typically a small
    //! room with very dead surfaces) to 20.0 (typically a large room with very live surfaces).
    //! Range: 0.1 to 20.0
    float DecayTime;

    //! The Decay HF Ratio property adjusts the spectral quality of the Decay Time parameter. It is the
    //! ratio of high-frequency decay time relative to the time set by Decay Time. The Decay HF Ratio
    //! value 1.0 is neutral: the decay time is equal for all frequencies. As Decay HF Ratio increases
    //! above 1.0, the high-frequency decay time increases so it's longer than the decay time at mid
    //! frequencies. You hear a more brilliant reverberation with a longer decay at high frequencies. As
    //! the Decay HF Ratio value decreases below 1.0, the high-frequency decay time decreases so it's
    //! shorter than the decay time of the mid frequencies. You hear a more natural reverberation.
    //! Range: 0.1 to 20.0
    float DecayHFRatio;

    //! The Decay LF Ratio property adjusts the spectral quality of the Decay Time parameter. It is the
    //! ratio of low-frequency decay time relative to the time set by Decay Time. The Decay LF Ratio
    //! value 1.0 is neutral: the decay time is equal for all frequencies. As Decay LF Ratio increases
    //! above 1.0, the low-frequency decay time increases so it's longer than the decay time at mid
    //! frequencies. You hear a more booming reverberation with a longer decay at low frequencies. As
    //! the Decay LF Ratio value decreases below 1.0, the low-frequency decay time decreases so it's
    //! shorter than the decay time of the mid frequencies. You hear a more tinny reverberation.
    //! Range: 0.1 to 20.0
    float DecayLFRatio;

    //! The Reflections Gain property controls the overall amount of initial reflections relative to the Gain
    //! property. (The Gain property sets the overall amount of reflected sound: both initial reflections
    //! and later reverberation.) The value of Reflections Gain ranges from a maximum of 3.16 (+10 dB)
    //! to a minimum of 0.0 (-100 dB) (no initial reflections at all), and is corrected by the value of the
    //! Gain property. The Reflections Gain property does not affect the subsequent reverberation decay.
    //! Range: 0.0 to 3.16
    float ReflectionsGain;

    //! The Reflections Delay property is the amount of delay between the arrival time of the direct path
    //! from the source to the first reflection from the source. It ranges from 0 to 300 milliseconds. You
    //! can reduce or increase Reflections Delay to simulate closer or more distant reflective surfaces—
    //! and therefore control the perceived size of the room.
    //! Range: 0.0 to 0.3
    float ReflectionsDelay;

    //! The Reflections Pan property is a 3D vector that controls the spatial distribution of the cluster of
    //! early reflections. The direction of this vector controls the global direction of the reflections, while
    //! its magnitude controls how focused the reflections are towards this direction.
    //! It is important to note that the direction of the vector is interpreted in the coordinate system of the
    //! user, without taking into account the orientation of the virtual listener. For instance, assuming a
    //! four-point loudspeaker playback system, setting Reflections Pan to (0, 0, 0.7) means that the
    //! reflections are panned to the front speaker pair, whereas as setting of (0, 0, -0.7) pans the
    //! reflections towards the rear speakers. These vectors follow the a left-handed co-ordinate system,
    //! unlike OpenAL uses a right-handed co-ordinate system.
    //! If the magnitude of Reflections Pan is zero (the default setting), the early reflections come evenly
    //! from all directions. As the magnitude increases, the reflections become more focused in the
    //! direction pointed to by the vector. A magnitude of 1.0 would represent the extreme case, where
    //! all reflections come from a single direction.
    cVector3 ReflectionsPan;

    //! The Late Reverb Gain property controls the overall amount of later reverberation relative to the
    //! Gain property. (The Gain property sets the overall amount of both initial reflections and later
    //! reverberation.) The value of Late Reverb Gain ranges from a maximum of 10.0 (+20 dB) to a
    //! minimum of 0.0 (-100 dB) (no late reverberation at all).
    //! Range: 0.0 to 10.0
    float LateReverbGain;

    //! The Late Reverb Delay property defines the begin time of the late reverberation relative to the
    //! time of the initial reflection (the first of the early reflections). It ranges from 0 to 100 milliseconds.
    //! Reducing or increasing Late Reverb Delay is useful for simulating a smaller or larger room.
    //! Range: 0.0 to 0.1
    float LateReverbDelay;

    //! The Late Reverb Pan property is a 3D vector that controls the spatial distribution of the late
    //! reverb. The direction of this vector controls the global direction of the reverb, while its magnitude
    //! controls how focused the reverb are towards this direction. The details under Reflections Pan,
    //! above, also apply to Late Reverb Pan.
    cVector3 LateReverbPan;

    //! Echo Time controls the rate at which the cyclic echo repeats itself along the
    //! reverberation decay. For example, the default setting for Echo Time is 250 ms. causing the echo
    //! to occur 4 times per second. Therefore, if you were to clap your hands in this type of
    //! environment, you will hear four repetitions of clap per second.
    //! Range: 0.075 to 0.25
    float EchoTime;

    //! Echo Depth introduces a cyclic echo in the reverberation decay, which will be noticeable with
    //! transient or percussive sounds. A larger value of Echo Depth will make this effect more
    //! prominent.
    //! Together with Reverb Diffusion, Echo Depth will control how long the echo effect will persist along
    //! the reverberation decay. In a more diffuse environment, echoes will wash out more quickly after
    //! the direct sound. In an environment that is less diffuse, you will be able to hear a larger number
    //! of repetitions of the echo, which will wash out later in the reverberation decay. If Diffusion is set
    //! to 0.0 and Echo Depth is set to 1.0, the echo will persist distinctly until the end of the
    //! reverberation decay.
    //! Range: 0.0 to 1.0
    float EchoDepth;

    //! Using these two properties below, you can create a pitch modulation in the reverberant sound. This will
    //! be most noticeable applied to sources that have tonal color or pitch. You can use this to make
    //! some trippy effects! Modulation Time controls the speed of the vibrato (rate of periodic changes in pitch).
    //! Range: 0.004 to 4.0
    float ModulationTime;

    //! Modulation Depth controls the amount of pitch change. Low values of Diffusion will contribute to
    //! reinforcing the perceived effect by reducing the mixing of overlapping reflections in the
    //! reverberation decay.
    //! Range: 0.0 to 1.0
    float ModulationDepth;

    //! The Air Absorption Gain HF property controls the distance-dependent attenuation at high
    //! frequencies caused by the propagation medium. It applies to reflected sound only. You can use
    //! Air Absorption Gain HF to simulate sound transmission through foggy air, dry air, smoky
    //! atmosphere, and so on. The default value is 0.994 (-0.05 dB) per meter, which roughly
    //! corresponds to typical condition of atmospheric humidity, temperature, and so on. Lowering the
    //! value simulates a more absorbent medium (more humidity in the air, for example); raising the
    //! value simulates a less absorbent medium (dry desert air, for example).
    //! Range: 0.892 to 1.0
    float AirAbsorptionGainHF;

    //! The properties HF Reference and LF Reference determine respectively the frequencies at which
    //! the high-frequency effects and the low-frequency effects created by EAX Reverb properties are
    //! measured, for example Decay HF Ratio and Decay LF Ratio.
    //! Note that it is necessary to maintain a factor of at least 10 between these two reference
    //! frequencies so that low frequency and high frequency properties can be accurately controlled and
    //! will produce independent effects. In other words, the LF Reference value should be less than
    //! 1/10 of the HF Reference value.
    //! Range: 1000.0 to 20000.0
    float HFReference;

    //! See HFReference.
    //! Range: 20.0 to 1000.0
    float LFReference;

    //! The Room Rolloff Factor property is one of two methods available to attenuate the reflected
    //! sound (containing both reflections and reverberation) according to source-listener distance. It's
    //! defined the same way as OpenAL's Rolloff Factor, but operates on reverb sound instead of
    //! direct-path sound. Setting the Room Rolloff Factor value to 1.0 specifies that the reflected sound
    //! will decay by 6 dB every time the distance doubles. Any value other than 1.0 is equivalent to a
    //! scaling factor applied to the quantity specified by ((Source listener distance) - (Reference
    //! Distance)). Reference Distance is an OpenAL source parameter that specifies the inner border
    //! for distance rolloff effects: if the source comes closer to the listener than the reference distance,
    //! the direct-path sound isn't increased as the source comes closer to the listener, and neither is the
    //! reflected sound.
    //! The default value of Room Rolloff Factor is 0.0 because, by default, the Effects Extension reverb
    //! effect naturally manages the reflected sound level automatically for each sound source to
    //! simulate the natural rolloff of reflected sound vs. distance in typical rooms.
    //! Range: 0.0 to 10.0
    float RoomRolloffFactor;

    //! When this flag is set, the high-frequency decay time automatically stays below a limit value that's
    //! derived from the setting of the property Air Absorption Gain HF. This limit applies regardless of
    //! the setting of the property Decay HF Ratio, and the limit doesn't affect the value of Decay HF
    //! Ratio. This limit, when on, maintains a natural sounding reverberation decay by allowing you to
    //! increase the value of Decay Time without the risk of getting an unnaturally long decay time at
    //! high frequencies. If this flag is set to false, high-frequency decay time isn't automatically
    //! limited.
    bool DecayHFLimit;
};

//! Similar to the above EAX Reverb Effect, but has less features, meaning it may be better supported on lower end hardware.
struct sReverbParameters
{
    sReverbParameters(
        float density = 1.0f,
        float diffusion = 1.0f,
        float gain = 0.32f,
        float gainHF = 0.89f,
        float decayTime = 1.49f,
        float decayHFRatio = 0.83f,
        float reflectionsGain = 0.05f,
        float reflectionsDelay = 0.007f,
        float lateReverbGain = 1.26f,
        float lateReverbDelay = 0.011f,
        float airAbsorptionGainHF = 0.994f,
        float roomRolloffFactor = 0.0f,
        bool decayHFLimit = true) :
        Density(density), Diffusion(diffusion), Gain(gain), GainHF(gainHF),
        DecayTime(decayTime), DecayHFRatio(decayHFRatio),
        ReflectionsGain(reflectionsGain), ReflectionsDelay(reflectionsDelay),
        LateReverbGain(lateReverbGain), LateReverbDelay(lateReverbDelay),
        AirAbsorptionGainHF(airAbsorptionGainHF), RoomRolloffFactor(roomRolloffFactor),
        DecayHFLimit(decayHFLimit) { }

    //! Reverb Modal Density controls the coloration of the late reverb. Lowering the value adds more
    //! coloration to the late reverb.
    //! Range: 0.0 to 1.0
    float Density;

    //! The Reverb Diffusion property controls the echo density in the reverberation decay. It's set by
    //! default to 1.0, which provides the highest density. Reducing diffusion gives the reverberation a
    //! more "grainy" character that is especially noticeable with percussive sound sources. If you set a
    //! diffusion value of 0.0, the later reverberation sounds like a succession of distinct echoes.
    //! Range: 0.0 to 1.0
    float Diffusion;

    //! The Reverb Gain property is the master volume control for the reflected sound (both early
    //! reflections and reverberation) that the reverb effect adds to all sound sources. It sets the
    //! maximum amount of reflections and reverberation added to the final sound mix. The value of the
    //! Reverb Gain property ranges from 1.0 (0db) (the maximum amount) to 0.0 (-100db) (no reflected
    //! sound at all).
    //! Range: 0.0 to 1.0
    float Gain;

    //! The Reverb Gain HF property further tweaks reflected sound by attenuating it at high frequencies.
    //! It controls a low-pass filter that applies globally to the reflected sound of all sound sources
    //! feeding the particular instance of the reverb effect. The value of the Reverb Gain HF property
    //! ranges from 1.0 (0db) (no filter) to 0.0 (-100db) (virtually no reflected sound).
    //! Range: 0.0 to 1.0
    float GainHF;

    //! The Decay Time property sets the reverberation decay time. It ranges from 0.1 (typically a small
    //! room with very dead surfaces) to 20.0 (typically a large room with very live surfaces).
    //! Range: 0.1 to 20.0
    float DecayTime;

    //! The Decay HF Ratio property sets the spectral quality of the Decay Time parameter. It is the
    //! ratio of high-frequency decay time relative to the time set by Decay Time. The Decay HF Ratio
    //! value 1.0 is neutral: the decay time is equal for all frequencies. As Decay HF Ratio increases
    //! above 1.0, the high-frequency decay time increases so it's longer than the decay time at low
    //! frequencies. You hear a more brilliant reverberation with a longer decay at high frequencies. As
    //! the Decay HF Ratio value decreases below 1.0, the high-frequency decay time decreases so it's
    //! shorter than the decay time of the low frequencies. You hear a more natural reverberation.
    //! Range: 0.1 to 2.0
    float DecayHFRatio;

    //! The Reflections Gain property controls the overall amount of initial reflections relative to the Gain
    //! property. (The Gain property sets the overall amount of reflected sound: both initial reflections
    //! and later reverberation.) The value of Reflections Gain ranges from a maximum of 3.16 (+10 dB)
    //! to a minimum of 0.0 (-100 dB) (no initial reflections at all), and is corrected by the value of the
    //! Gain property. The Reflections Gain property does not affect the subsequent reverberation
    //! decay.
    //! Range: 0.0 to 3.16
    float ReflectionsGain;

    //! The Reflections Delay property is the amount of delay between the arrival time of the direct path
    //! from the source to the first reflection from the source. It ranges from 0 to 300 milliseconds. You
    //! can reduce or increase Reflections Delay to simulate closer or more distant reflective surfaces—
    //! and therefore control the perceived size of the room.
    //! Range: 0.0 to 0.3
    float ReflectionsDelay;

    //! The Late Reverb Gain property controls the overall amount of later reverberation relative to the
    //! Gain property. (The Gain property sets the overall amount of both initial reflections and later
    //! reverberation.) The value of Late Reverb Gain ranges from a maximum of 10.0 (+20 dB) to a
    //! minimum of 0.0 (-100 dB) (no late reverberation at all).
    //! Range: 0.0 to 10.0
    float LateReverbGain;

    //! The Late Reverb Delay property defines the begin time of the late reverberation relative to the
    //! time of the initial reflection (the first of the early reflections). It ranges from 0 to 100 milliseconds.
    //! Reducing or increasing Late Reverb Delay is useful for simulating a smaller or larger room.
    //! Range: 0.0 to 0.1
    float LateReverbDelay;

    //! The Air Absorption Gain HF property controls the distance-dependent attenuation at high
    //! frequencies caused by the propagation medium. It applies to reflected sound only. You can use
    //! Air Absorption Gain HF to simulate sound transmission through foggy air, dry air, smoky
    //! atmosphere, and so on. The default value is 0.994 (-0.05 dB) per meter, which roughly
    //! corresponds to typical condition of atmospheric humidity, temperature, and so on. Lowering the
    //! value simulates a more absorbent medium (more humidity in the air, for example); raising the
    //! value simulates a less absorbent medium (dry desert air, for example).
    //! Range: 0.892 to 1.0
    float AirAbsorptionGainHF;

    //! The Room Rolloff Factor property is one of two methods available to attenuate the reflected
    //! sound (containing both reflections and reverberation) according to source-listener distance. It's
    //! defined the same way as OpenAL's Rolloff Factor, but operates on reverb sound instead of
    //! direct-path sound. Setting the Room Rolloff Factor value to 1.0 specifies that the reflected sound
    //! will decay by 6 dB every time the distance doubles. Any value other than 1.0 is equivalent to a
    //! scaling factor applied to the quantity specified by ((Source listener distance) - (Reference
    //! Distance)). Reference Distance is an OpenAL source parameter that specifies the inner border
    //! for distance rolloff effects: if the source comes closer to the listener than the reference distance,
    //! the direct-path sound isn't increased as the source comes closer to the listener, and neither is the
    //! reflected sound.
    //! The default value of Room Rolloff Factor is 0.0 because, by default, the Effects Extension reverb
    //! effect naturally manages the reflected sound level automatically for each sound source to
    //! simulate the natural rolloff of reflected sound vs. distance in typical rooms.
    //! Range: 0.0 to 10.0
    float RoomRolloffFactor;

    //! When this flag is set, the high-frequency decay time automatically stays below a limit value that's
    //! derived from the setting of the property Air Absorption Gain HF. This limit applies regardless of
    //! the setting of the property Decay HF Ratio, and the limit doesn't affect the value of Decay HF
    //! Ratio. This limit, when on, maintains a natural sounding reverberation decay by allowing you to
    //! increase the value of Decay Time without the risk of getting an unnaturally long decay time at
    //! high frequencies. If this flag is set to false, high-frequency decay time isn't automatically
    //! limited.
    bool DecayHFLimit;
};

//! The chorus effect essentially replays the input audio accompanied by another slightly delayed version of the signal, creating a "doubling" effect.
struct sChorusParameters
{
    enum ChorusWaveform
    {
        ECW_SINUSOID,
        ECW_TRIANGLE,
        ECW_COUNT
    };
    sChorusParameters(
        ChorusWaveform waveform = ECW_TRIANGLE,
        int phase = 90,
        float rate = 1.1f,
        float depth = 0.1f,
        float feedback = 0.25f,
        float delay = 0.016f) :
        Waveform(waveform), Phase(phase), Rate(rate), Depth(depth), Feedback(feedback),
        Delay(delay) { }

    //! This property sets the waveform shape of the LFO that controls the delay time of the delayed signals.
    ChorusWaveform Waveform;

    //! This property controls the phase difference between the left and right LFO's. At zero degrees the
    //! two LFOs are synchronized. Use this parameter to create the illusion of an expanded stereo field
    //! of the output signal.
    //! Range: -180 to 180
    int Phase;

    //! This property sets the modulation rate of the LFO that controls the delay time of the delayed signals.
    //! Range: 0.0 to 10.0
    float Rate;

    //! This property controls the amount by which the delay time is modulated by the LFO.
    //! Range: 0.0 to 1.0
    float Depth;

    //! This property controls the amount of processed signal that is fed back to the input of the chorus
    //! effect. Negative values will reverse the phase of the feedback signal. At full magnitude the
    //! identical sample will repeat endlessly. At lower magnitudes the sample will repeat and fade out
    //! over time. Use this parameter to create a "cascading" chorus effect.
    //! Range: -1.0 to 1.0
    float Feedback;

    //! This property controls the average amount of time the sample is delayed before it is played back,
    //! and with feedback, the amount of time between iterations of the sample. Larger values lower the
    //! pitch. Smaller values make the chorus sound like a flanger, but with different frequency
    //! characteristics.
    //! Range: 0.0 to 0.016
    float Delay;
};

//! The distortion effect simulates turning up (overdriving) the gain stage on a guitar amplifier or adding a distortion pedal to an instrument's output.
struct sDistortionParameters
{
    sDistortionParameters(
        float edge = 0.2f,
        float gain = 0.05f,
        float lowpassCutoff = 8000.0f,
        float eqCenter = 3600.0f,
        float eqBandwidth = 3600.0f) :
        Edge(edge), Gain(gain), LowpassCutoff(lowpassCutoff), EqCenter(eqCenter),
        EqBandwidth(eqBandwidth) { }

    //! This property controls the shape of the distortion. The higher the value for Edge, the "dirtier" and "fuzzier" the effect.
    //! Range: 0.0 to 1.0
    float Edge;

    //! This property allows you to attenuate the distorted sound.
    //! Range: 0.01 to 1.0
    float Gain;

    //! Input signal can have a low pass filter applied, to limit the amount of high frequency signal feeding into the distortion effect.
    //! Range: 80.0 to 24000.0
    float LowpassCutoff;

    //! This property controls the frequency at which the post-distortion attenuation (Gain) is active.
    //! Range: 80.0 to 24000.0
    float EqCenter;

    //! This property controls the bandwidth of the post-distortion attenuation.
    //! Range: 80.0 to 24000.0
    float EqBandwidth;
};

//! The echo effect generates discrete, delayed instances of the input signal.
struct sEchoParameters
{
    sEchoParameters(
        float delay = 0.1f,
        float lRDelay = 0.1f,
        float damping = 0.5f,
        float feedback = 0.5f,
        float spread = -1.0f) :
        Delay(delay), LRDelay(lRDelay), Damping(damping), Feedback(feedback),
        Spread(spread) { }

    //! This property controls the delay between the original sound and the first "tap", or echo instance.
    //! Range: 0.0 to 0.207
    float Delay;

    //! This property controls the delay between the first "tap" and the second "tap".
    //! Range: 0.0 to 0.404
    float LRDelay;

    //! This property controls the amount of high frequency damping applied to each echo. As the sound
    //! is subsequently fed back for further echoes, damping results in an echo which progressively gets
    //! softer in tone as well as intensity.
    //! Range: 0.0 to 0.99
    float Damping;

    //! This property controls the amount of feedback the output signal fed back into the input. Use this
    //! parameter to create "cascading" echoes. At full magnitude, the identical sample will repeat
    //! endlessly. Below full magnitude, the sample will repeat and fade.
    //! Range: 0.0 to 1.0
    float Feedback;

    //! This property controls how hard panned the individual echoes are. With a value of 1.0, the first
    //! "tap" will be panned hard left, and the second "tap" hard right. A value of -1.0 gives the opposite
    //! result. Settings nearer to 0.0 result in less emphasized panning.
    //! Range: -1.0 to 1.0
    float Spread;
};

//! The flanger effect creates a "tearing" or "whooshing" sound (like a jet flying overhead).
struct sFlangerParameters
{
    enum FlangerWaveform
    {
        EFW_SINUSOID,
        EFW_TRIANGLE,
        EFW_COUNT
    };
    sFlangerParameters(
        FlangerWaveform waveform = EFW_TRIANGLE,
        int phase = 0,
        float rate = 0.27f,
        float depth = 1.0f,
        float feedback = -0.5f,
        float delay = 0.002f) :
        Waveform(waveform), Phase(phase), Rate(rate), Depth(depth), Feedback(feedback),
        Delay(delay) { }

    //! Selects the shape of the LFO waveform that controls the amount of the delay of the sampled signal.
    FlangerWaveform Waveform;

    //! This changes the phase difference between the left and right LFO's. At zero degrees the two LFOs are synchronized.
    //! Range: -180 to 180
    int Phase;

    //! The number of times per second the LFO controlling the amount of delay repeats. Higher values increase the pitch modulation.
    //! Range: 0.0 to 10.0
    float Rate;

    //! The ratio by which the delay time is modulated by the LFO. Use this parameter to increase the pitch modulation.
    //! Range: 0.0 to 1.0
    float Depth;

    //! This is the amount of the output signal level fed back into the effect's input.
    //! A negative value will reverse the phase of the feedback signal. Use this parameter
    //! to create an "intense metallic" effect. At full magnitude, the identical sample will
    //! repeat endlessly. At less than full magnitude, the sample will repeat and fade out over time.
    //! Range: -1.0 to 1.0
    float Feedback;

    //! The average amount of time the sample is delayed before it is played back; with feedback, the amount of time between iterations of the sample.
    //! Range: 0.0 to 0.004
    float Delay;
};

//! The frequency shifter is a single-sideband modulator, which translates all the component frequencies of the input signal by an equal amount.
struct sFrequencyShiftParameters
{
    enum ShiftDirection
    {
        ESD_DOWN,
        ESD_UP,
        ESD_OFF,
        ESD_COUNT
    };
    sFrequencyShiftParameters(
        float frequency = 0.0f,
        ShiftDirection left = ESD_DOWN,
        ShiftDirection right = ESD_DOWN) :
        Frequency(frequency), Left(left), Right(right) { }

    //! This is the carrier frequency. For carrier frequencies below the audible range, the singlesideband
    //! modulator may produce phaser effects, spatial effects or a slight pitch-shift. As the
    //! carrier frequency increases, the timbre of the sound is affected; a piano or guitar note becomes
    //! like a bell's chime, and a human voice sounds extraterrestrial!
    //! Range: 0.0 to 24000.0
    float Frequency;

    //! These select which internal signals are added together to produce the output. Different
    //! combinations of values will produce slightly different tonal and spatial effects.
    ShiftDirection Left;

    //! These select which internal signals are added together to produce the output. Different
    //! combinations of values will produce slightly different tonal and spatial effects.
    ShiftDirection Right;
};

//! The vocal morpher consists of a pair of 4-band formant filters, used to impose vocal tract effects upon the input signal.
struct sVocalMorpherParameters
{
    enum MorpherPhoneme
    {
        EMP_A,
        EMP_E,
        EMP_I,
        EMP_O,
        EMP_U,
        EMP_AA,
        EMP_AE,
        EMP_AH,
        EMP_AO,
        EMP_EH,
        EMP_ER,
        EMP_IH,
        EMP_IY,
        EMP_UH,
        EMP_UW,
        EMP_B,
        EMP_D,
        EMP_F,
        EMP_G,
        EMP_J,
        EMP_K,
        EMP_L,
        EMP_M,
        EMP_N,
        EMP_P,
        EMP_R,
        EMP_S,
        EMP_T,
        EMP_V,
        EMP_Z,
        ESD_COUNT
    };

    enum MorpherWaveform
    {
        EMW_SINUSOID,
        EMW_TRIANGLE,
        EMW_SAW,
        EMW_COUNT
    };
    sVocalMorpherParameters(
        MorpherPhoneme phonemeA = EMP_A,
        MorpherPhoneme phonemeB = EMP_ER,
        int phonemeACoarseTune = 0,
        int phonemeBCoarseTune = 0,
        MorpherWaveform waveform = EMW_SINUSOID,
        float rate = 1.41f) :
        PhonemeA(phonemeA), PhonemeB(phonemeB), PhonemeACoarseTune(phonemeACoarseTune),
        PhonemeBCoarseTune(phonemeBCoarseTune), Waveform(waveform), Rate(rate) { }

    //! If both parameters are set to the same phoneme, that determines the filtering effect that will be
    //! heard. If these two parameters are set to different phonemes, the filtering effect will morph
    //! between the two settings at a rate specified by Rate.
    MorpherPhoneme PhonemeA;

    //! If both parameters are set to the same phoneme, that determines the filtering effect that will be
    //! heard. If these two parameters are set to different phonemes, the filtering effect will morph
    //! between the two settings at a rate specified by Rate.
    MorpherPhoneme PhonemeB;

    //! This is used to adjust the pitch of phoneme filter A in 1-semitone increments.
    //! Range: -24 to 24
    int PhonemeACoarseTune;

    //! This is used to adjust the pitch of phoneme filter B in 1-semitone increments.
    //! Range: -24 to 24
    int PhonemeBCoarseTune;

    //! This controls the shape of the low-frequency oscillator used to morph between the two phoneme filters.
    MorpherWaveform Waveform;

    //! This controls the frequency of the low-frequency oscillator used to morph between the two phoneme filters.
    //! Range: 0.0 to 10.0
    float Rate;
};

//! The pitch shifter applies time-invariant pitch shifting to the input signal, over a one octave range and controllable at a semi-tone and cent resolution.
struct sPitchShifterParameters
{
    sPitchShifterParameters(
        int coarseTune = 12,
        int fineTune = 0) :
        CoarseTune(coarseTune), FineTune(fineTune) { }

    //! This sets the number of semitones by which the pitch is shifted. There are 12 semitones per
    //! octave. Negative values create a downwards shift in pitch, positive values pitch the sound
    //! upwards.
    //! Range: -12 to 12
    int CoarseTune;

    //! This sets the number of cents between Semitones a pitch is shifted. A Cent is 1/100th of a
    //! Semitone. Negative values create a downwards shift in pitch, positive values pitch the sound
    //! upwards.
    //! Range: -50 to 50
    int FineTune;
};

//! The ring modulator multiplies an input signal by a carrier signal in the time domain, resulting in tremolo or inharmonic effects.
struct sRingModulatorParameters
{
    enum ModulatorWaveform
    {
        EMW_SINUSOID,
        EMW_SAW,
        EMW_SQUARE,
        EMW_COUNT
    };
    sRingModulatorParameters(
        float frequency = 440.0f,
        float highPassCutoff = 800.0f,
        ModulatorWaveform waveform = EMW_SINUSOID) :
        Frequency(frequency), HighPassCutoff(highPassCutoff), Waveform(waveform) { }

    //! This is the frequency of the carrier signal. If the carrier signal is slowly varying (less than 20 Hz),
    //! the result is a tremolo (slow amplitude variation) effect. If the carrier signal is in the audio range,
    //! audible upper and lower sidebands begin to appear, causing an inharmonic effect. The carrier
    //! signal itself is not heard in the output.
    //! Range: 0.0 to 8000.0
    float Frequency;

    //! This controls the cutoff frequency at which the input signal is high-pass filtered before being ring
    //! modulated. If the cutoff frequency is 0, the entire signal will be ring modulated. If the cutoff
    //! frequency is high, very little of the signal (only those parts above the cutoff) will be ring
    //! modulated.
    //! Range: 0.0 to 24000.0
    float HighPassCutoff;

    //! This controls which waveform is used as the carrier signal. Traditional ring modulator and
    //! tremolo effects generally use a sinusoidal carrier. Sawtooth and square waveforms are may
    //! cause unpleasant aliasing.
    ModulatorWaveform Waveform;
};

//! The Auto-wah effect emulates the sound of a wah-wah pedal used with an electric guitar, or a mute on a brass instrument.
struct sAutowahParameters
{
    sAutowahParameters(
        float attackTime = 0.06f,
        float releaseTime = 0.06f,
        float resonance = 1000.0f,
        float peakGain = 11.22f) :
        AttackTime(attackTime), ReleaseTime(releaseTime), Resonance(resonance),
        PeakGain(peakGain) { }

    //! This property controls the time the filtering effect takes to sweep from minimum to maximum center frequency when it is triggered by input signal.
    //! Range: 0.0001 to 1.0
    float AttackTime;

    //! This property controls the time the filtering effect takes to sweep from maximum back to base center frequency, when the input signal ends.
    //! Range: 0.0001 to 1.0
    float ReleaseTime;

    //! This property controls the resonant peak, sometimes known as emphasis or Q, of the auto-wah
    //! band-pass filter. Resonance occurs when the effect boosts the frequency content of the sound
    //! around the point at which the filter is working. A high value promotes a highly resonant, sharp
    //! sounding effect.
    //! Range: 2.0 to 1000.0
    float Resonance;

    //! This property controls the input signal level at which the band-pass filter will be fully opened.
    //! Range: 0.00003 to 31621.0
    float PeakGain;
};

//! The Automatic Gain Control effect performs the same task as a studio compressor, evening out the audio dynamic range of an input sound.
struct sCompressorParameters
{
    sCompressorParameters(
        bool active = true) :
        Active(active) { }

    //! The Compressor can only be switched on and off – it cannot be adjusted.
    bool Active;
};

//! The OpenAL Effects Extension EQ is very flexible, providing tonal control over four different adjustable frequency ranges.
struct sEqualizerParameters
{
    sEqualizerParameters(
        float lowGain = 1.0f,
        float lowCutoff = 200.0f,
        float mid1Gain = 1.0f,
        float mid1Center = 500.0f,
        float mid1Width = 1.0f,
        float mid2Gain = 1.0f,
        float mid2Center = 3000.0f,
        float mid2Width = 1.0f,
        float highGain = 1.0f,
        float highCutoff = 6000.0f) :
        LowGain(lowGain), LowCutoff(lowCutoff), Mid1Gain(mid1Gain),
        Mid1Center(mid1Center), Mid1Width(mid1Width), Mid2Gain(mid2Gain),
        Mid2Center(mid2Center), Mid2Width(mid2Width), HighGain(highGain),
        HighCutoff(highCutoff) { }

    //! This property controls amount of cut or boost on the low frequency range.
    //! Range: 0.126 to 7.943
    float LowGain;

    //! This property controls the low frequency below which signal will be cut off.
    //! Range: 50.0 to 800.0
    float LowCutoff;

    //! This property allows you to cut / boost signal on the "mid1" range.
    //! Range: 0.126 to 7.943
    float Mid1Gain;

    //! This property sets the center frequency for the "mid1" range.
    //! Range: 200.0 to 3000.0
    float Mid1Center;

    //! This property controls the width of the "mid1" range.
    //! Range: 0.01 to 1.0
    float Mid1Width;

    //! This property allows you to cut / boost signal on the "mid2" range.
    //! Range: 0.126 to 7.943
    float Mid2Gain;

    //! This property sets the center frequency for the "mid2" range.
    //! Range: 1000.0 to 8000.0
    float Mid2Center;

    //! This property controls the width of the "mid2" range.
    //! Range: 0.01 to 1.0
    float Mid2Width;

    //! This property allows you to cut / boost the signal at high frequencies.
    //! Range: 0.126 to 7.943
    float HighGain;

    //! This property controls the high frequency above which signal will be cut off.
    //! Range: 4000.0 to 16000.0
    float HighCutoff;
};
};

#endif

#endif //! IEFFECTPARAMETERS_H
