aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Alc/effects/chorus.c32
-rw-r--r--Alc/effects/compressor.c16
-rw-r--r--Alc/effects/dedicated.c16
-rw-r--r--Alc/effects/distortion.c16
-rw-r--r--Alc/effects/echo.c16
-rw-r--r--Alc/effects/equalizer.c16
-rw-r--r--Alc/effects/modulator.c16
-rw-r--r--Alc/effects/null.c18
-rw-r--r--Alc/effects/reverb.c16
-rw-r--r--OpenAL32/Include/alAuxEffectSlot.h41
-rw-r--r--OpenAL32/alAuxEffectSlot.c38
11 files changed, 121 insertions, 120 deletions
diff --git a/Alc/effects/chorus.c b/Alc/effects/chorus.c
index 666933a8..4f8c7ce3 100644
--- a/Alc/effects/chorus.c
+++ b/Alc/effects/chorus.c
@@ -285,11 +285,11 @@ static ALvoid ALchorusState_process(ALchorusState *state, ALsizei SamplesToDo, c
}
-typedef struct ALchorusStateFactory {
- DERIVE_FROM_TYPE(ALeffectStateFactory);
-} ALchorusStateFactory;
+typedef struct ChorusStateFactory {
+ DERIVE_FROM_TYPE(EffectStateFactory);
+} ChorusStateFactory;
-static ALeffectState *ALchorusStateFactory_create(ALchorusStateFactory *UNUSED(factory))
+static ALeffectState *ChorusStateFactory_create(ChorusStateFactory *UNUSED(factory))
{
ALchorusState *state;
@@ -299,14 +299,14 @@ static ALeffectState *ALchorusStateFactory_create(ALchorusStateFactory *UNUSED(f
return STATIC_CAST(ALeffectState, state);
}
-DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALchorusStateFactory);
+DEFINE_EFFECTSTATEFACTORY_VTABLE(ChorusStateFactory);
-ALeffectStateFactory *ALchorusStateFactory_getFactory(void)
+EffectStateFactory *ChorusStateFactory_getFactory(void)
{
- static ALchorusStateFactory ChorusFactory = { { GET_VTABLE2(ALchorusStateFactory, ALeffectStateFactory) } };
+ static ChorusStateFactory ChorusFactory = { { GET_VTABLE2(ChorusStateFactory, EffectStateFactory) } };
- return STATIC_CAST(ALeffectStateFactory, &ChorusFactory);
+ return STATIC_CAST(EffectStateFactory, &ChorusFactory);
}
@@ -422,11 +422,11 @@ DEFINE_ALEFFECT_VTABLE(ALchorus);
/* Flanger is basically a chorus with a really short delay. They can both use
* the same processing functions, so piggyback flanger on the chorus functions.
*/
-typedef struct ALflangerStateFactory {
- DERIVE_FROM_TYPE(ALeffectStateFactory);
-} ALflangerStateFactory;
+typedef struct FlangerStateFactory {
+ DERIVE_FROM_TYPE(EffectStateFactory);
+} FlangerStateFactory;
-ALeffectState *ALflangerStateFactory_create(ALflangerStateFactory *UNUSED(factory))
+ALeffectState *FlangerStateFactory_create(FlangerStateFactory *UNUSED(factory))
{
ALchorusState *state;
@@ -436,13 +436,13 @@ ALeffectState *ALflangerStateFactory_create(ALflangerStateFactory *UNUSED(factor
return STATIC_CAST(ALeffectState, state);
}
-DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALflangerStateFactory);
+DEFINE_EFFECTSTATEFACTORY_VTABLE(FlangerStateFactory);
-ALeffectStateFactory *ALflangerStateFactory_getFactory(void)
+EffectStateFactory *FlangerStateFactory_getFactory(void)
{
- static ALflangerStateFactory FlangerFactory = { { GET_VTABLE2(ALflangerStateFactory, ALeffectStateFactory) } };
+ static FlangerStateFactory FlangerFactory = { { GET_VTABLE2(FlangerStateFactory, EffectStateFactory) } };
- return STATIC_CAST(ALeffectStateFactory, &FlangerFactory);
+ return STATIC_CAST(EffectStateFactory, &FlangerFactory);
}
diff --git a/Alc/effects/compressor.c b/Alc/effects/compressor.c
index bb9be8b9..4ec28f9a 100644
--- a/Alc/effects/compressor.c
+++ b/Alc/effects/compressor.c
@@ -179,11 +179,11 @@ static ALvoid ALcompressorState_process(ALcompressorState *state, ALsizei Sample
}
-typedef struct ALcompressorStateFactory {
- DERIVE_FROM_TYPE(ALeffectStateFactory);
-} ALcompressorStateFactory;
+typedef struct CompressorStateFactory {
+ DERIVE_FROM_TYPE(EffectStateFactory);
+} CompressorStateFactory;
-static ALeffectState *ALcompressorStateFactory_create(ALcompressorStateFactory *UNUSED(factory))
+static ALeffectState *CompressorStateFactory_create(CompressorStateFactory *UNUSED(factory))
{
ALcompressorState *state;
@@ -193,13 +193,13 @@ static ALeffectState *ALcompressorStateFactory_create(ALcompressorStateFactory *
return STATIC_CAST(ALeffectState, state);
}
-DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALcompressorStateFactory);
+DEFINE_EFFECTSTATEFACTORY_VTABLE(CompressorStateFactory);
-ALeffectStateFactory *ALcompressorStateFactory_getFactory(void)
+EffectStateFactory *CompressorStateFactory_getFactory(void)
{
- static ALcompressorStateFactory CompressorFactory = { { GET_VTABLE2(ALcompressorStateFactory, ALeffectStateFactory) } };
+ static CompressorStateFactory CompressorFactory = { { GET_VTABLE2(CompressorStateFactory, EffectStateFactory) } };
- return STATIC_CAST(ALeffectStateFactory, &CompressorFactory);
+ return STATIC_CAST(EffectStateFactory, &CompressorFactory);
}
diff --git a/Alc/effects/dedicated.c b/Alc/effects/dedicated.c
index 70a97ea9..b9dd7db3 100644
--- a/Alc/effects/dedicated.c
+++ b/Alc/effects/dedicated.c
@@ -114,11 +114,11 @@ static ALvoid ALdedicatedState_process(ALdedicatedState *state, ALsizei SamplesT
}
-typedef struct ALdedicatedStateFactory {
- DERIVE_FROM_TYPE(ALeffectStateFactory);
-} ALdedicatedStateFactory;
+typedef struct DedicatedStateFactory {
+ DERIVE_FROM_TYPE(EffectStateFactory);
+} DedicatedStateFactory;
-ALeffectState *ALdedicatedStateFactory_create(ALdedicatedStateFactory *UNUSED(factory))
+ALeffectState *DedicatedStateFactory_create(DedicatedStateFactory *UNUSED(factory))
{
ALdedicatedState *state;
@@ -128,14 +128,14 @@ ALeffectState *ALdedicatedStateFactory_create(ALdedicatedStateFactory *UNUSED(fa
return STATIC_CAST(ALeffectState, state);
}
-DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALdedicatedStateFactory);
+DEFINE_EFFECTSTATEFACTORY_VTABLE(DedicatedStateFactory);
-ALeffectStateFactory *ALdedicatedStateFactory_getFactory(void)
+EffectStateFactory *DedicatedStateFactory_getFactory(void)
{
- static ALdedicatedStateFactory DedicatedFactory = { { GET_VTABLE2(ALdedicatedStateFactory, ALeffectStateFactory) } };
+ static DedicatedStateFactory DedicatedFactory = { { GET_VTABLE2(DedicatedStateFactory, EffectStateFactory) } };
- return STATIC_CAST(ALeffectStateFactory, &DedicatedFactory);
+ return STATIC_CAST(EffectStateFactory, &DedicatedFactory);
}
diff --git a/Alc/effects/distortion.c b/Alc/effects/distortion.c
index 6ee89594..b112032c 100644
--- a/Alc/effects/distortion.c
+++ b/Alc/effects/distortion.c
@@ -176,11 +176,11 @@ static ALvoid ALdistortionState_process(ALdistortionState *state, ALsizei Sample
}
-typedef struct ALdistortionStateFactory {
- DERIVE_FROM_TYPE(ALeffectStateFactory);
-} ALdistortionStateFactory;
+typedef struct DistortionStateFactory {
+ DERIVE_FROM_TYPE(EffectStateFactory);
+} DistortionStateFactory;
-static ALeffectState *ALdistortionStateFactory_create(ALdistortionStateFactory *UNUSED(factory))
+static ALeffectState *DistortionStateFactory_create(DistortionStateFactory *UNUSED(factory))
{
ALdistortionState *state;
@@ -190,14 +190,14 @@ static ALeffectState *ALdistortionStateFactory_create(ALdistortionStateFactory *
return STATIC_CAST(ALeffectState, state);
}
-DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALdistortionStateFactory);
+DEFINE_EFFECTSTATEFACTORY_VTABLE(DistortionStateFactory);
-ALeffectStateFactory *ALdistortionStateFactory_getFactory(void)
+EffectStateFactory *DistortionStateFactory_getFactory(void)
{
- static ALdistortionStateFactory DistortionFactory = { { GET_VTABLE2(ALdistortionStateFactory, ALeffectStateFactory) } };
+ static DistortionStateFactory DistortionFactory = { { GET_VTABLE2(DistortionStateFactory, EffectStateFactory) } };
- return STATIC_CAST(ALeffectStateFactory, &DistortionFactory);
+ return STATIC_CAST(EffectStateFactory, &DistortionFactory);
}
diff --git a/Alc/effects/echo.c b/Alc/effects/echo.c
index d8cbd214..34010c47 100644
--- a/Alc/effects/echo.c
+++ b/Alc/effects/echo.c
@@ -206,11 +206,11 @@ static ALvoid ALechoState_process(ALechoState *state, ALsizei SamplesToDo, const
}
-typedef struct ALechoStateFactory {
- DERIVE_FROM_TYPE(ALeffectStateFactory);
-} ALechoStateFactory;
+typedef struct EchoStateFactory {
+ DERIVE_FROM_TYPE(EffectStateFactory);
+} EchoStateFactory;
-ALeffectState *ALechoStateFactory_create(ALechoStateFactory *UNUSED(factory))
+ALeffectState *EchoStateFactory_create(EchoStateFactory *UNUSED(factory))
{
ALechoState *state;
@@ -220,13 +220,13 @@ ALeffectState *ALechoStateFactory_create(ALechoStateFactory *UNUSED(factory))
return STATIC_CAST(ALeffectState, state);
}
-DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALechoStateFactory);
+DEFINE_EFFECTSTATEFACTORY_VTABLE(EchoStateFactory);
-ALeffectStateFactory *ALechoStateFactory_getFactory(void)
+EffectStateFactory *EchoStateFactory_getFactory(void)
{
- static ALechoStateFactory EchoFactory = { { GET_VTABLE2(ALechoStateFactory, ALeffectStateFactory) } };
+ static EchoStateFactory EchoFactory = { { GET_VTABLE2(EchoStateFactory, EffectStateFactory) } };
- return STATIC_CAST(ALeffectStateFactory, &EchoFactory);
+ return STATIC_CAST(EffectStateFactory, &EchoFactory);
}
diff --git a/Alc/effects/equalizer.c b/Alc/effects/equalizer.c
index 8c2b31e2..22db5d54 100644
--- a/Alc/effects/equalizer.c
+++ b/Alc/effects/equalizer.c
@@ -196,11 +196,11 @@ static ALvoid ALequalizerState_process(ALequalizerState *state, ALsizei SamplesT
}
-typedef struct ALequalizerStateFactory {
- DERIVE_FROM_TYPE(ALeffectStateFactory);
-} ALequalizerStateFactory;
+typedef struct EqualizerStateFactory {
+ DERIVE_FROM_TYPE(EffectStateFactory);
+} EqualizerStateFactory;
-ALeffectState *ALequalizerStateFactory_create(ALequalizerStateFactory *UNUSED(factory))
+ALeffectState *EqualizerStateFactory_create(EqualizerStateFactory *UNUSED(factory))
{
ALequalizerState *state;
@@ -210,13 +210,13 @@ ALeffectState *ALequalizerStateFactory_create(ALequalizerStateFactory *UNUSED(fa
return STATIC_CAST(ALeffectState, state);
}
-DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALequalizerStateFactory);
+DEFINE_EFFECTSTATEFACTORY_VTABLE(EqualizerStateFactory);
-ALeffectStateFactory *ALequalizerStateFactory_getFactory(void)
+EffectStateFactory *EqualizerStateFactory_getFactory(void)
{
- static ALequalizerStateFactory EqualizerFactory = { { GET_VTABLE2(ALequalizerStateFactory, ALeffectStateFactory) } };
+ static EqualizerStateFactory EqualizerFactory = { { GET_VTABLE2(EqualizerStateFactory, EffectStateFactory) } };
- return STATIC_CAST(ALeffectStateFactory, &EqualizerFactory);
+ return STATIC_CAST(EffectStateFactory, &EqualizerFactory);
}
diff --git a/Alc/effects/modulator.c b/Alc/effects/modulator.c
index ed0851d6..74a0d0c5 100644
--- a/Alc/effects/modulator.c
+++ b/Alc/effects/modulator.c
@@ -186,11 +186,11 @@ static ALvoid ALmodulatorState_process(ALmodulatorState *state, ALsizei SamplesT
}
-typedef struct ALmodulatorStateFactory {
- DERIVE_FROM_TYPE(ALeffectStateFactory);
-} ALmodulatorStateFactory;
+typedef struct ModulatorStateFactory {
+ DERIVE_FROM_TYPE(EffectStateFactory);
+} ModulatorStateFactory;
-static ALeffectState *ALmodulatorStateFactory_create(ALmodulatorStateFactory *UNUSED(factory))
+static ALeffectState *ModulatorStateFactory_create(ModulatorStateFactory *UNUSED(factory))
{
ALmodulatorState *state;
@@ -200,13 +200,13 @@ static ALeffectState *ALmodulatorStateFactory_create(ALmodulatorStateFactory *UN
return STATIC_CAST(ALeffectState, state);
}
-DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALmodulatorStateFactory);
+DEFINE_EFFECTSTATEFACTORY_VTABLE(ModulatorStateFactory);
-ALeffectStateFactory *ALmodulatorStateFactory_getFactory(void)
+EffectStateFactory *ModulatorStateFactory_getFactory(void)
{
- static ALmodulatorStateFactory ModulatorFactory = { { GET_VTABLE2(ALmodulatorStateFactory, ALeffectStateFactory) } };
+ static ModulatorStateFactory ModulatorFactory = { { GET_VTABLE2(ModulatorStateFactory, EffectStateFactory) } };
- return STATIC_CAST(ALeffectStateFactory, &ModulatorFactory);
+ return STATIC_CAST(EffectStateFactory, &ModulatorFactory);
}
diff --git a/Alc/effects/null.c b/Alc/effects/null.c
index f9583011..e57359e3 100644
--- a/Alc/effects/null.c
+++ b/Alc/effects/null.c
@@ -85,12 +85,12 @@ static void ALnullState_Delete(void *ptr)
}
-typedef struct ALnullStateFactory {
- DERIVE_FROM_TYPE(ALeffectStateFactory);
-} ALnullStateFactory;
+typedef struct NullStateFactory {
+ DERIVE_FROM_TYPE(EffectStateFactory);
+} NullStateFactory;
/* Creates ALeffectState objects of the appropriate type. */
-ALeffectState *ALnullStateFactory_create(ALnullStateFactory *UNUSED(factory))
+ALeffectState *NullStateFactory_create(NullStateFactory *UNUSED(factory))
{
ALnullState *state;
@@ -100,13 +100,13 @@ ALeffectState *ALnullStateFactory_create(ALnullStateFactory *UNUSED(factory))
return STATIC_CAST(ALeffectState, state);
}
-/* Define the ALeffectStateFactory vtable for this type. */
-DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALnullStateFactory);
+/* Define the EffectStateFactory vtable for this type. */
+DEFINE_EFFECTSTATEFACTORY_VTABLE(NullStateFactory);
-ALeffectStateFactory *ALnullStateFactory_getFactory(void)
+EffectStateFactory *NullStateFactory_getFactory(void)
{
- static ALnullStateFactory NullFactory = { { GET_VTABLE2(ALnullStateFactory, ALeffectStateFactory) } };
- return STATIC_CAST(ALeffectStateFactory, &NullFactory);
+ static NullStateFactory NullFactory = { { GET_VTABLE2(NullStateFactory, EffectStateFactory) } };
+ return STATIC_CAST(EffectStateFactory, &NullFactory);
}
diff --git a/Alc/effects/reverb.c b/Alc/effects/reverb.c
index f6499bb7..f9650c8b 100644
--- a/Alc/effects/reverb.c
+++ b/Alc/effects/reverb.c
@@ -1691,11 +1691,11 @@ static ALvoid ALreverbState_process(ALreverbState *State, ALsizei SamplesToDo, c
}
-typedef struct ALreverbStateFactory {
- DERIVE_FROM_TYPE(ALeffectStateFactory);
-} ALreverbStateFactory;
+typedef struct ReverbStateFactory {
+ DERIVE_FROM_TYPE(EffectStateFactory);
+} ReverbStateFactory;
-static ALeffectState *ALreverbStateFactory_create(ALreverbStateFactory* UNUSED(factory))
+static ALeffectState *ReverbStateFactory_create(ReverbStateFactory* UNUSED(factory))
{
ALreverbState *state;
@@ -1705,13 +1705,13 @@ static ALeffectState *ALreverbStateFactory_create(ALreverbStateFactory* UNUSED(f
return STATIC_CAST(ALeffectState, state);
}
-DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALreverbStateFactory);
+DEFINE_EFFECTSTATEFACTORY_VTABLE(ReverbStateFactory);
-ALeffectStateFactory *ALreverbStateFactory_getFactory(void)
+EffectStateFactory *ReverbStateFactory_getFactory(void)
{
- static ALreverbStateFactory ReverbFactory = { { GET_VTABLE2(ALreverbStateFactory, ALeffectStateFactory) } };
+ static ReverbStateFactory ReverbFactory = { { GET_VTABLE2(ReverbStateFactory, EffectStateFactory) } };
- return STATIC_CAST(ALeffectStateFactory, &ReverbFactory);
+ return STATIC_CAST(EffectStateFactory, &ReverbFactory);
}
diff --git a/OpenAL32/Include/alAuxEffectSlot.h b/OpenAL32/Include/alAuxEffectSlot.h
index aa3a0118..29de7a14 100644
--- a/OpenAL32/Include/alAuxEffectSlot.h
+++ b/OpenAL32/Include/alAuxEffectSlot.h
@@ -59,21 +59,22 @@ static const struct ALeffectStateVtable T##_ALeffectState_vtable = { \
}
-struct ALeffectStateFactoryVtable;
+struct EeffectStateFactoryVtable;
-typedef struct ALeffectStateFactory {
- const struct ALeffectStateFactoryVtable *vtbl;
-} ALeffectStateFactory;
+typedef struct EffectStateFactory {
+ const struct EffectStateFactoryVtable *vtab;
+} EffectStateFactory;
-struct ALeffectStateFactoryVtable {
- ALeffectState *(*const create)(ALeffectStateFactory *factory);
+struct EffectStateFactoryVtable {
+ ALeffectState *(*const create)(EffectStateFactory *factory);
};
+#define EffectStateFactory_create(x) ((x)->vtab->create((x)))
-#define DEFINE_ALEFFECTSTATEFACTORY_VTABLE(T) \
-DECLARE_THUNK(T, ALeffectStateFactory, ALeffectState*, create) \
+#define DEFINE_EFFECTSTATEFACTORY_VTABLE(T) \
+DECLARE_THUNK(T, EffectStateFactory, ALeffectState*, create) \
\
-static const struct ALeffectStateFactoryVtable T##_ALeffectStateFactory_vtable = { \
- T##_ALeffectStateFactory_create, \
+static const struct EffectStateFactoryVtable T##_EffectStateFactory_vtable = { \
+ T##_EffectStateFactory_create, \
}
@@ -156,17 +157,17 @@ void UpdateAllEffectSlotProps(ALCcontext *context);
ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *Context);
-ALeffectStateFactory *ALnullStateFactory_getFactory(void);
-ALeffectStateFactory *ALreverbStateFactory_getFactory(void);
-ALeffectStateFactory *ALchorusStateFactory_getFactory(void);
-ALeffectStateFactory *ALcompressorStateFactory_getFactory(void);
-ALeffectStateFactory *ALdistortionStateFactory_getFactory(void);
-ALeffectStateFactory *ALechoStateFactory_getFactory(void);
-ALeffectStateFactory *ALequalizerStateFactory_getFactory(void);
-ALeffectStateFactory *ALflangerStateFactory_getFactory(void);
-ALeffectStateFactory *ALmodulatorStateFactory_getFactory(void);
+EffectStateFactory *NullStateFactory_getFactory(void);
+EffectStateFactory *ReverbStateFactory_getFactory(void);
+EffectStateFactory *ChorusStateFactory_getFactory(void);
+EffectStateFactory *CompressorStateFactory_getFactory(void);
+EffectStateFactory *DistortionStateFactory_getFactory(void);
+EffectStateFactory *EchoStateFactory_getFactory(void);
+EffectStateFactory *EqualizerStateFactory_getFactory(void);
+EffectStateFactory *FlangerStateFactory_getFactory(void);
+EffectStateFactory *ModulatorStateFactory_getFactory(void);
-ALeffectStateFactory *ALdedicatedStateFactory_getFactory(void);
+EffectStateFactory *DedicatedStateFactory_getFactory(void);
ALenum InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect *effect);
diff --git a/OpenAL32/alAuxEffectSlot.c b/OpenAL32/alAuxEffectSlot.c
index d5c39051..04edcc09 100644
--- a/OpenAL32/alAuxEffectSlot.c
+++ b/OpenAL32/alAuxEffectSlot.c
@@ -43,23 +43,23 @@ static void RemoveActiveEffectSlots(const ALuint *slotids, ALsizei count, ALCcon
static const struct {
ALenum Type;
- ALeffectStateFactory* (*GetFactory)(void);
+ EffectStateFactory* (*GetFactory)(void);
} FactoryList[] = {
- { AL_EFFECT_NULL, ALnullStateFactory_getFactory },
- { AL_EFFECT_EAXREVERB, ALreverbStateFactory_getFactory },
- { AL_EFFECT_REVERB, ALreverbStateFactory_getFactory },
- { AL_EFFECT_CHORUS, ALchorusStateFactory_getFactory },
- { AL_EFFECT_COMPRESSOR, ALcompressorStateFactory_getFactory },
- { AL_EFFECT_DISTORTION, ALdistortionStateFactory_getFactory },
- { AL_EFFECT_ECHO, ALechoStateFactory_getFactory },
- { AL_EFFECT_EQUALIZER, ALequalizerStateFactory_getFactory },
- { AL_EFFECT_FLANGER, ALflangerStateFactory_getFactory },
- { AL_EFFECT_RING_MODULATOR, ALmodulatorStateFactory_getFactory },
- { AL_EFFECT_DEDICATED_DIALOGUE, ALdedicatedStateFactory_getFactory },
- { AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT, ALdedicatedStateFactory_getFactory }
+ { AL_EFFECT_NULL, NullStateFactory_getFactory },
+ { AL_EFFECT_EAXREVERB, ReverbStateFactory_getFactory },
+ { AL_EFFECT_REVERB, ReverbStateFactory_getFactory },
+ { AL_EFFECT_CHORUS, ChorusStateFactory_getFactory },
+ { AL_EFFECT_COMPRESSOR, CompressorStateFactory_getFactory },
+ { AL_EFFECT_DISTORTION, DistortionStateFactory_getFactory },
+ { AL_EFFECT_ECHO, EchoStateFactory_getFactory },
+ { AL_EFFECT_EQUALIZER, EqualizerStateFactory_getFactory },
+ { AL_EFFECT_FLANGER, FlangerStateFactory_getFactory },
+ { AL_EFFECT_RING_MODULATOR, ModulatorStateFactory_getFactory },
+ { AL_EFFECT_DEDICATED_DIALOGUE, DedicatedStateFactory_getFactory },
+ { AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT, DedicatedStateFactory_getFactory }
};
-static inline ALeffectStateFactory *getFactoryByType(ALenum type)
+static inline EffectStateFactory *getFactoryByType(ALenum type)
{
size_t i;
for(i = 0;i < COUNTOF(FactoryList);i++)
@@ -498,7 +498,7 @@ ALenum InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect
if(newtype != EffectSlot->Effect.Type)
{
- ALeffectStateFactory *factory;
+ EffectStateFactory *factory;
factory = getFactoryByType(newtype);
if(!factory)
@@ -506,7 +506,7 @@ ALenum InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect
ERR("Failed to find factory for effect type 0x%04x\n", newtype);
return AL_INVALID_ENUM;
}
- State = V0(factory,create)();
+ State = EffectStateFactory_create(factory);
if(!State) return AL_OUT_OF_MEMORY;
START_MIXER_MODE();
@@ -659,13 +659,13 @@ static void RemoveActiveEffectSlots(const ALuint *slotids, ALsizei count, ALCcon
ALenum InitEffectSlot(ALeffectslot *slot)
{
- ALeffectStateFactory *factory;
+ EffectStateFactory *factory;
slot->Effect.Type = AL_EFFECT_NULL;
factory = getFactoryByType(AL_EFFECT_NULL);
- if(!(slot->Effect.State=V0(factory,create)()))
- return AL_OUT_OF_MEMORY;
+ slot->Effect.State = EffectStateFactory_create(factory);
+ if(!slot->Effect.State) return AL_OUT_OF_MEMORY;
slot->Gain = 1.0;
slot->AuxSendAuto = AL_TRUE;
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-20 12:45:34 +0000