IEffectParameters.h

// Copyright (c) 2008-2011 Raynaldo (Wildicv) Rivera, Joshua (Dark_Kilauea) Jones, Murat (wolfmanfx) Sari
// This file is part of the "cAudio Engine"
// For conditions of distribution and use, see copyright notice in cAudio.h
 
#pragma once
 
#include "cVector3.h"
#include "cAudioDefines.h"
 
#if CAUDIO_EFX_ENABLED == 1
 
namespace cAudio
{
        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) { }
 
                float Density;
 
                float Diffusion;
 
                float Gain;
 
                float GainHF;
 
                float GainLF;
 
                float DecayTime;
 
                float DecayHFRatio;
 
                float DecayLFRatio;
 
                float ReflectionsGain;
 
                float ReflectionsDelay;
 
                cVector3 ReflectionsPan;
 
                float LateReverbGain;
 
                float LateReverbDelay;
 
                cVector3 LateReverbPan;
 
                float EchoTime;
 
                float EchoDepth;
                
                float ModulationTime;
 
                float ModulationDepth;
 
                float AirAbsorptionGainHF;
 
                float HFReference;
 
                float LFReference;
 
                float RoomRolloffFactor;
 
                bool DecayHFLimit;
        };
 
        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) { }
 
                float Density;
 
                float Diffusion;
 
                float Gain;
 
                float GainHF;
 
                float DecayTime;
 
                float DecayHFRatio;
 
                float ReflectionsGain;
 
                float ReflectionsDelay;
 
                float LateReverbGain;
 
                float LateReverbDelay;
 
                float AirAbsorptionGainHF;
 
                float RoomRolloffFactor;
 
                bool DecayHFLimit;
        };
 
        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) { }
 
                ChorusWaveform Waveform;
 
                int Phase;
 
                float Rate;
 
                float Depth;
 
                float Feedback;
 
                float Delay;
        };
 
        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) { }
 
                float Edge;
 
                float Gain;
 
                float LowpassCutoff;
 
                float EqCenter;
 
                float EqBandwidth;
        };
 
        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) { }
 
                float Delay;
 
                float LRDelay;
 
                float Damping;
 
                float Feedback;
 
                float Spread;
        };
 
        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) { }
 
                FlangerWaveform Waveform;
 
                int Phase;
 
                float Rate;
 
                float Depth;
 
                float Feedback;
 
                float Delay;
        };
 
        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) { }
 
                float Frequency;
 
                ShiftDirection Left;
 
                ShiftDirection Right;
        };
 
        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) { }
 
                MorpherPhoneme PhonemeA;
 
                MorpherPhoneme PhonemeB;
 
                int PhonemeACoarseTune;
 
                int PhonemeBCoarseTune;
 
                MorpherWaveform Waveform;
 
                float Rate;
        };
 
        struct sPitchShifterParameters
        {
                sPitchShifterParameters(
                        int coarseTune = 12,
                        int fineTune = 0) : 
                        CoarseTune(coarseTune), FineTune(fineTune) { }
 
                int CoarseTune;
 
                int FineTune;
        };
 
        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) { }
 
                float Frequency;
 
                float HighPassCutoff;
 
                ModulatorWaveform Waveform;
        };
 
        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) { }
 
                float AttackTime;
 
                float ReleaseTime;
 
                float Resonance;
 
                float PeakGain;
        };
 
        struct sCompressorParameters
        {
                sCompressorParameters(
                        bool active = true) : 
                        Active(active) { }
 
                bool Active;
        };
 
        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) { }
 
                float LowGain;
 
                float LowCutoff;
 
                float Mid1Gain;
 
                float Mid1Center;
 
                float Mid1Width;
 
                float Mid2Gain;
 
                float Mid2Center;
 
                float Mid2Width;
 
                float HighGain;
 
                float HighCutoff;
        };
};
 
#endif