diff --git a/rwengine/CMakeLists.txt b/rwengine/CMakeLists.txt
index cddfe5f9e..b2a22c53a 100644
--- a/rwengine/CMakeLists.txt
+++ b/rwengine/CMakeLists.txt
@@ -24,6 +24,14 @@ set(RWENGINE_SOURCES
     src/audio/SoundManager.hpp
     src/audio/SoundSource.cpp
     src/audio/SoundSource.hpp
+    src/audio/EffectSlot.hpp
+    src/audio/EffectSlot.cpp
+    src/audio/SoundEffect.cpp
+    src/audio/SoundEffect.hpp
+    src/audio/ReverbEffect.cpp
+    src/audio/ReverbEffect.hpp
+    src/audio/OpenAlExtensions.hpp
+    src/audio/OpenAlExtensions.cpp
 
     src/core/Logger.cpp
     src/core/Logger.hpp
diff --git a/rwengine/src/audio/EffectSlot.cpp b/rwengine/src/audio/EffectSlot.cpp
new file mode 100644
index 000000000..18ef435ff
--- /dev/null
+++ b/rwengine/src/audio/EffectSlot.cpp
@@ -0,0 +1,37 @@
+#include "EffectSlot.hpp"
+#include "SoundEffect.hpp"
+#include "OpenAlExtensions.hpp"
+
+EffectSlot::EffectSlot() {
+    alGenAuxiliaryEffectSlots(1, &slotId);
+
+    created = alGetError() == AL_NO_ERROR;
+}
+
+EffectSlot::~EffectSlot() {
+    alDeleteAuxiliaryEffectSlots(1, &slotId);
+}
+
+bool EffectSlot::attachEffect(std::shared_ptr<SoundEffect> effect) {
+    alAuxiliaryEffectSloti(slotId, AL_EFFECTSLOT_EFFECT, effect->getId());
+
+    if (alGetError() != AL_NO_ERROR) {
+        return false;
+    }
+
+    this->effect = std::move(effect);
+
+    return true;
+}
+
+bool EffectSlot::detachEffect() {
+    alAuxiliaryEffectSloti(slotId, AL_EFFECTSLOT_EFFECT, 0);
+    this->effect = nullptr;
+
+    return alGetError() == AL_NO_ERROR;
+}
+
+void EffectSlot::setGain(float gain) {
+    this->gain = gain;
+    alAuxiliaryEffectSlotf(slotId, AL_EFFECTSLOT_GAIN, gain);
+}
diff --git a/rwengine/src/audio/EffectSlot.hpp b/rwengine/src/audio/EffectSlot.hpp
new file mode 100644
index 000000000..0f02a50f7
--- /dev/null
+++ b/rwengine/src/audio/EffectSlot.hpp
@@ -0,0 +1,62 @@
+#ifndef EFFECTSLOT_H
+#define EFFECTSLOT_H
+
+#include <al.h>
+
+#include <memory>
+
+class SoundEffect;
+
+/**
+ * Effect slot.
+ *
+ * Many sound sources can be attached to one slot.
+ * Different effects can be binded to this (e.g reverb, delay).
+ */
+class EffectSlot {
+public:
+    EffectSlot();
+    ~EffectSlot();
+
+    /**
+     * Attach effect to this slot.
+     *
+     * @param sound effect (e.g reverb, delay)
+     * @return true if effect attached successfully, false otherwise
+     */
+    bool attachEffect(std::shared_ptr<SoundEffect> effect);
+
+    /**
+     * Detach current effect from this slot.
+     * @return true if effect detached successfully, false otherwise
+     */
+    bool detachEffect();
+
+    void setGain(float gain);
+
+    ALuint getSlotId() const {
+        return slotId;
+    }
+
+    int getSlotNumber() const {
+        return slotNumber;
+    }
+
+private:
+    /**
+     * Effect binded to this slot
+     */
+    std::shared_ptr<SoundEffect> effect;
+
+    ALuint slotId;
+    /**
+     * This is flag of successfull slot creation
+     */
+    bool created;
+    float gain = 1.0f;
+
+    /// OpenAL aux slot
+    int slotNumber = 0;
+};
+
+#endif // EFFECTSLOT_H
diff --git a/rwengine/src/audio/OpenAlExtensions.cpp b/rwengine/src/audio/OpenAlExtensions.cpp
new file mode 100644
index 000000000..ead6089bc
--- /dev/null
+++ b/rwengine/src/audio/OpenAlExtensions.cpp
@@ -0,0 +1,25 @@
+#include "OpenAlExtensions.hpp"
+
+LPALGENEFFECTS alGenEffects = nullptr;
+LPALDELETEEFFECTS alDeleteEffects = nullptr;
+LPALEFFECTI alEffecti = nullptr;
+LPALEFFECTF alEffectf = nullptr;
+
+// Auxiliary slot object
+LPALGENAUXILIARYEFFECTSLOTS alGenAuxiliaryEffectSlots    = nullptr;
+LPALDELETEAUXILIARYEFFECTSLOTS alDeleteAuxiliaryEffectSlots = nullptr;
+LPALAUXILIARYEFFECTSLOTI alAuxiliaryEffectSloti = nullptr;
+LPALAUXILIARYEFFECTSLOTF alAuxiliaryEffectSlotf = nullptr;
+
+void initEfxFunctionPointers() {
+    alGenEffects = reinterpret_cast<LPALGENEFFECTS>(alGetProcAddress("alGenEffects"));
+    alDeleteEffects = reinterpret_cast<LPALDELETEEFFECTS>(alGetProcAddress("alDeleteEffects"));
+    alEffecti = reinterpret_cast<LPALEFFECTI>(alGetProcAddress("alEffecti"));
+    alEffectf = reinterpret_cast<LPALEFFECTF>(alGetProcAddress("alEffectf"));
+
+    // aux slot
+    alGenAuxiliaryEffectSlots = reinterpret_cast<LPALGENAUXILIARYEFFECTSLOTS>(alGetProcAddress("alGenAuxiliaryEffectSlots"));
+    alDeleteAuxiliaryEffectSlots = reinterpret_cast<LPALDELETEAUXILIARYEFFECTSLOTS>(alGetProcAddress("alDeleteAuxiliaryEffectSlots"));
+    alAuxiliaryEffectSloti = reinterpret_cast<LPALAUXILIARYEFFECTSLOTI>(alGetProcAddress("alAuxiliaryEffectSloti"));
+    alAuxiliaryEffectSlotf = reinterpret_cast<LPALAUXILIARYEFFECTSLOTF>(alGetProcAddress("alAuxiliaryEffectSlotf"));
+}
diff --git a/rwengine/src/audio/OpenAlExtensions.hpp b/rwengine/src/audio/OpenAlExtensions.hpp
new file mode 100644
index 000000000..ee700f3ad
--- /dev/null
+++ b/rwengine/src/audio/OpenAlExtensions.hpp
@@ -0,0 +1,26 @@
+#ifndef OPENALEXTENSIONS_HPP
+#define OPENALEXTENSIONS_HPP
+
+#include <efx.h>
+
+/**
+ * Functions to access OpenAL EFX extension
+ */
+
+extern LPALGENEFFECTS alGenEffects;
+extern LPALDELETEEFFECTS alDeleteEffects;
+extern LPALEFFECTI alEffecti;
+extern LPALEFFECTF alEffectf;
+
+// Aux slot
+extern LPALGENAUXILIARYEFFECTSLOTS alGenAuxiliaryEffectSlots;
+extern LPALDELETEAUXILIARYEFFECTSLOTS alDeleteAuxiliaryEffectSlots;
+extern LPALAUXILIARYEFFECTSLOTI alAuxiliaryEffectSloti;
+extern LPALAUXILIARYEFFECTSLOTF alAuxiliaryEffectSlotf;
+
+/**
+ * Initialize function pointers
+ */
+void initEfxFunctionPointers();
+
+#endif // OPENALEXTENSIONS_HPP
diff --git a/rwengine/src/audio/ReverbEffect.cpp b/rwengine/src/audio/ReverbEffect.cpp
new file mode 100644
index 000000000..e48b43736
--- /dev/null
+++ b/rwengine/src/audio/ReverbEffect.cpp
@@ -0,0 +1,44 @@
+#include "ReverbEffect.hpp"
+#include "OpenAlExtensions.hpp"
+#include <efx.h>
+
+ReverbEffect::ReverbEffect() : SoundEffect (AL_EFFECT_REVERB) {
+
+}
+
+
+void ReverbEffect::setDensity(float d) {
+    alEffectf(id, AL_REVERB_DENSITY, d);
+}
+
+void ReverbEffect::setDiffusion(float d) {
+    alEffectf(id, AL_REVERB_DIFFUSION, d);
+}
+
+void ReverbEffect::setGain(float g) {
+    alEffectf(id, AL_REVERB_GAIN, g);
+}
+
+void ReverbEffect::setGainHf(float g) {
+    alEffectf(id, AL_REVERB_GAINHF, g);
+}
+
+void ReverbEffect::setDecayTime(float t) {
+    alEffectf(id, AL_REVERB_DECAY_TIME, t);
+}
+
+void ReverbEffect::setLateReverbGain(float g) {
+    alEffectf(id, AL_REVERB_LATE_REVERB_GAIN, g);
+}
+
+void ReverbEffect::setLateReverbDelay(float t) {
+    alEffectf(id, AL_REVERB_LATE_REVERB_DELAY, t);
+}
+
+void ReverbEffect::setAirAbsorptionGainHf(float g) {
+    alEffectf(id, AL_REVERB_AIR_ABSORPTION_GAINHF, g);
+}
+
+void ReverbEffect::setDecayHfLimit(bool flag) {
+    alEffecti(id, AL_REVERB_DECAY_HFLIMIT, flag ? AL_TRUE : AL_FALSE);
+}
diff --git a/rwengine/src/audio/ReverbEffect.hpp b/rwengine/src/audio/ReverbEffect.hpp
new file mode 100644
index 000000000..6a1f46b92
--- /dev/null
+++ b/rwengine/src/audio/ReverbEffect.hpp
@@ -0,0 +1,22 @@
+#ifndef REVERBEFFECT_H
+#define REVERBEFFECT_H
+
+#include "SoundEffect.hpp"
+
+class ReverbEffect : public SoundEffect {
+
+public:
+    ReverbEffect();
+
+    void setDensity(float density = 1.0f);
+    void setDiffusion(float diffusion = 0.3f);
+    void setGain(float gain = 0.92f);
+    void setGainHf(float gainHf = 0.89f);
+    void setDecayTime(float decayTime = 5.49f);
+    void setLateReverbGain(float lateReverbGain = 1.26f );
+    void setLateReverbDelay(float lateReverbDelay = 0.011f);
+    void setAirAbsorptionGainHf(float absorptionGainHf = 0.994f);
+    void setDecayHfLimit(bool decayHfLimit = true);
+};
+
+#endif // REVERBEFFECT_H
diff --git a/rwengine/src/audio/Sound.cpp b/rwengine/src/audio/Sound.cpp
index df934cd78..d186fd975 100644
--- a/rwengine/src/audio/Sound.cpp
+++ b/rwengine/src/audio/Sound.cpp
@@ -2,6 +2,13 @@
 
 #include "audio/SoundBuffer.hpp"
 
+Sound::~Sound()
+{
+    if (effect != nullptr) {
+        buffer->disableEffect(effect);
+    }
+}
+
 bool Sound::isPlaying() const {
     return buffer->isPlaying();
 }
@@ -46,6 +53,12 @@ void Sound::setMaxDistance(float maxDist) {
     buffer->setMaxDistance(maxDist);
 }
 
+void Sound::enableEffect(std::shared_ptr<SoundEffect> effect)
+{
+    this->effect = std::move(effect);
+    buffer->enableEffect(this->effect);
+}
+
 size_t Sound::getScriptObjectID() const {
     return id;
 }
diff --git a/rwengine/src/audio/Sound.hpp b/rwengine/src/audio/Sound.hpp
index fbb29122b..6eb857cbf 100644
--- a/rwengine/src/audio/Sound.hpp
+++ b/rwengine/src/audio/Sound.hpp
@@ -1,9 +1,12 @@
 #ifndef _RWENGINE_SOUND_HPP_
 #define _RWENGINE_SOUND_HPP_
 
+#include <audio/SoundEffect.hpp>
+
 #include <glm/vec3.hpp>
 
 #include <memory>
+#include <optional>
 
 class SoundSource;
 struct SoundBuffer;
@@ -18,8 +21,10 @@ struct Sound {
     std::shared_ptr<SoundSource> source;
     std::unique_ptr<SoundBuffer> buffer;
 
+    std::shared_ptr<SoundEffect> effect;
+
     Sound() = default;
-    ~Sound() = default;
+    ~Sound();
 
     bool isPlaying() const;
 
@@ -42,6 +47,8 @@ struct Sound {
 
     void setMaxDistance(float maxDist);
 
+    void enableEffect(std::shared_ptr<SoundEffect> effect);
+
     size_t getScriptObjectID() const;
 };
 #endif
diff --git a/rwengine/src/audio/SoundBuffer.cpp b/rwengine/src/audio/SoundBuffer.cpp
index 9d367eb83..313815e33 100644
--- a/rwengine/src/audio/SoundBuffer.cpp
+++ b/rwengine/src/audio/SoundBuffer.cpp
@@ -1,9 +1,11 @@
 #include "audio/SoundBuffer.hpp"
 
 #include <rw/types.hpp>
+#include <efx.h>
 
 #include "audio/alCheck.hpp"
 #include "audio/SoundSource.hpp"
+#include "audio/SoundEffect.hpp"
 
 SoundBuffer::SoundBuffer() {
     alCheck(alGenSources(1, &source));
@@ -83,3 +85,11 @@ void SoundBuffer::setGain(float gain) {
 void SoundBuffer::setMaxDistance(float maxDist) {
     alCheck(alSourcef(source, AL_MAX_DISTANCE, maxDist));
 }
+
+void SoundBuffer::enableEffect(std::shared_ptr<SoundEffect> effect) {
+    alCheck(alSource3i(source, AL_AUXILIARY_SEND_FILTER, (ALint) effect->getSlotId(), effect->getSlotNumber(), AL_FILTER_NULL));
+}
+
+void SoundBuffer::disableEffect(std::shared_ptr<SoundEffect> effect) {
+    alCheck(alSource3i (source, AL_AUXILIARY_SEND_FILTER, AL_EFFECTSLOT_NULL, effect->getSlotNumber(), AL_FILTER_NULL));
+}
diff --git a/rwengine/src/audio/SoundBuffer.hpp b/rwengine/src/audio/SoundBuffer.hpp
index 2a5f6949e..c82e9aa29 100644
--- a/rwengine/src/audio/SoundBuffer.hpp
+++ b/rwengine/src/audio/SoundBuffer.hpp
@@ -4,6 +4,9 @@
 #include <al.h>
 #include <glm/vec3.hpp>
 
+#include <memory>
+
+class SoundEffect;
 class SoundSource;
 
 /// OpenAL tool for playing
@@ -27,6 +30,9 @@ struct SoundBuffer {
     void setGain(float gain);
     void setMaxDistance(float maxDist);
 
+    void enableEffect(std::shared_ptr<SoundEffect> effect);
+    void disableEffect(std::shared_ptr<SoundEffect> effect);
+
     ALuint source;
     ALuint buffer;
 };
diff --git a/rwengine/src/audio/SoundEffect.cpp b/rwengine/src/audio/SoundEffect.cpp
new file mode 100644
index 000000000..0647a04f5
--- /dev/null
+++ b/rwengine/src/audio/SoundEffect.cpp
@@ -0,0 +1,47 @@
+#include "SoundEffect.hpp"
+#include "OpenAlExtensions.hpp"
+
+SoundEffect::SoundEffect(ALint type) {
+    // reset error
+    alGetError();
+
+    alGenEffects(1, &id);
+
+    created = alGetError() == AL_NO_ERROR;
+    if (!created) {
+        return;
+    }
+
+    alEffecti(id, AL_EFFECT_TYPE, type);
+
+    created = alGetError() == AL_NO_ERROR;
+    if (!created) {
+        return;
+    }
+
+    alGenAuxiliaryEffectSlots(1, &slotId);
+
+    created = alGetError() == AL_NO_ERROR;
+    if (!created) {
+        return;
+    }
+
+    alAuxiliaryEffectSloti(slotId, AL_EFFECTSLOT_EFFECT, (ALint) id);
+
+    created = alGetError() == AL_NO_ERROR;
+    if (!created) {
+        return;
+    }
+
+    created = alGetError() == AL_NO_ERROR;
+}
+
+SoundEffect::~SoundEffect() {
+    alDeleteEffects(1, &id);
+    alDeleteAuxiliaryEffectSlots(1, &slotId);
+}
+
+void SoundEffect::setGain(float gain) {
+    this->gain = gain;
+    alAuxiliaryEffectSlotf(slotId, AL_EFFECTSLOT_GAIN, gain);
+}
diff --git a/rwengine/src/audio/SoundEffect.hpp b/rwengine/src/audio/SoundEffect.hpp
new file mode 100644
index 000000000..143c3110b
--- /dev/null
+++ b/rwengine/src/audio/SoundEffect.hpp
@@ -0,0 +1,64 @@
+#ifndef SOUNDEFFECT_H
+#define SOUNDEFFECT_H
+
+#include <al.h>
+
+/**
+ * Class to represent any effect.
+ *
+ * Any concrete realisation should have own class
+ * in order to be able to set different effect-specific parameters.
+ */
+class SoundEffect {
+
+public:
+    /**
+     * Known SoundEffect types
+     */
+    enum Type {
+        None,
+        Reverb
+    };
+
+    /**
+     * Create effect
+     * @param type OpenAl specific effect type.
+     */
+    SoundEffect(ALint type);
+    virtual ~SoundEffect();
+
+    ALuint getId() const {
+        return id;
+    }
+
+    ALuint getSlotId() const {
+        return slotId;
+    }
+
+    int getSlotNumber() const {
+        return slotNumber;
+    }
+
+    void setGain(float gain);
+
+protected:
+    /**
+     * Effect openal id
+     */
+    ALuint id;
+
+private:
+    /**
+     * Effect created successfully if this is true after construction
+     */
+    bool created;
+
+    ALuint slotId;
+
+    float gain = 1.0f;
+
+    /// OpenAL aux slot
+    int slotNumber = 0;
+};
+
+#endif // SOUNDEFFECT_H
diff --git a/rwengine/src/audio/SoundManager.cpp b/rwengine/src/audio/SoundManager.cpp
index 328feef79..2ea815820 100644
--- a/rwengine/src/audio/SoundManager.cpp
+++ b/rwengine/src/audio/SoundManager.cpp
@@ -5,12 +5,15 @@ extern "C" {
 #include <libavformat/avformat.h>
 #include <libavformat/avio.h>
 #include <libavutil/avutil.h>
+#include <efx.h>
 }
 
 #include "audio/alCheck.hpp"
 #include "audio/Sound.hpp"
 #include "audio/SoundBuffer.hpp"
 #include "audio/SoundSource.hpp"
+#include "audio/OpenAlExtensions.hpp"
+#include "audio/ReverbEffect.hpp"
 #include "engine/GameData.hpp"
 #include "engine/GameWorld.hpp"
 #include "render/ViewCamera.hpp"
@@ -34,6 +37,7 @@ Sound& SoundManager::getSoundRef(const std::string& name) {
 SoundManager::SoundManager() {
     initializeOpenAL();
     initializeAVCodec();
+    initializeEFX();
 }
 
 SoundManager::SoundManager(GameWorld* engine) : _engine(engine) {
@@ -43,6 +47,7 @@ SoundManager::SoundManager(GameWorld* engine) : _engine(engine) {
 
     initializeOpenAL();
     initializeAVCodec();
+    initializeEFX();
 }
 
 SoundManager::~SoundManager() {
@@ -87,6 +92,22 @@ void SoundManager::initializeAVCodec() {
 #endif
 }
 
+bool SoundManager::initializeEFX() {
+    if (!alcIsExtensionPresent(alDevice, ALC_EXT_EFX_NAME)) {
+        RW_ERROR("EFX extention is not present");
+        return false;
+    }
+
+    initEfxFunctionPointers();
+
+    // first effect is placeholder
+    // it allows index to be like in enum
+    soundEffects.push_back(nullptr);
+    soundEffects.push_back(std::make_shared<ReverbEffect>());
+
+    return true;
+}
+
 void SoundManager::deinitializeOpenAL() {
     // Buffers have to been removed before openAL is deinitialized
     sounds.clear();
@@ -138,7 +159,7 @@ void SoundManager::loadSound(size_t index) {
 
     sound->source = std::make_shared<SoundSource>();
     sound->source->loadSfx(sdt, index);
-}
+ }
 
 size_t SoundManager::createSfxInstance(size_t index) {
     Sound* sound = nullptr;
@@ -228,8 +249,11 @@ void SoundManager::eraseSound(const std::string& name) {
     }
 }
 
-void SoundManager::playSfx(size_t name, const glm::vec3& position, bool looping,
-                           int maxDist) {
+void SoundManager::playSfx(size_t name, const glm::vec3& position, bool looping, int maxDist) {
+    playSfx(name, position, SoundEffect::Type::Reverb, looping, maxDist);
+}
+
+void SoundManager::playSfx(size_t name, const glm::vec3& position, SoundEffect::Type effectType, bool looping, int maxDist) {
     auto buffer = buffers.find(name);
     if (buffer != buffers.end()) {
         buffer->second.setPosition(position);
@@ -242,6 +266,9 @@ void SoundManager::playSfx(size_t name, const glm::vec3& position, bool looping,
         if (maxDist != -1) {
             buffer->second.setMaxDistance(static_cast<float>(maxDist));
         }
+
+        auto effect = soundEffects.at(static_cast<size_t>(effectType));
+        buffer->second.enableEffect(effect);
         buffer->second.play();
     }
 }
diff --git a/rwengine/src/audio/SoundManager.hpp b/rwengine/src/audio/SoundManager.hpp
index 07efda605..3efe24d15 100644
--- a/rwengine/src/audio/SoundManager.hpp
+++ b/rwengine/src/audio/SoundManager.hpp
@@ -2,6 +2,7 @@
 #define _RWENGINE_SOUNDMANAGER_HPP_
 
 #include "audio/Sound.hpp"
+#include "audio/SoundEffect.hpp"
 
 #include <alc.h>
 
@@ -62,8 +63,10 @@ class SoundManager {
     /// allows also for setting position,
     /// looping and max Distance.
     /// -1 means no limit of max distance.
-    void playSfx(size_t name, const glm::vec3& position, bool looping = false,
-                 int maxDist = -1);
+    void playSfx(size_t name, const glm::vec3& position, bool looping = false, int maxDist = -1);
+
+    void playSfx(size_t name, const glm::vec3& position, SoundEffect::Type effect = SoundEffect::Type::Reverb,
+                 bool looping = false, int maxDist = -1);
 
     void pauseAllSounds();
     void resumeAllSounds();
@@ -91,6 +94,9 @@ class SoundManager {
     bool initializeOpenAL();
     void initializeAVCodec();
 
+    /// Initialize EFX OpenAL extention
+    bool initializeEFX();
+
     void deinitializeOpenAL();
 
     ALCcontext* alContext = nullptr;
@@ -117,6 +123,9 @@ class SoundManager {
 
     /// Multiplier for music and cutscenes audio
     float _musicVolume = 1.f;
+
+    /// Available sound effects for sfx
+    std::vector<std::shared_ptr<SoundEffect>> soundEffects;
 };
 
 #endif
diff --git a/rwengine/src/render/ObjectRenderer.cpp b/rwengine/src/render/ObjectRenderer.cpp
index 358696d21..a98f3a6b5 100644
--- a/rwengine/src/render/ObjectRenderer.cpp
+++ b/rwengine/src/render/ObjectRenderer.cpp
@@ -307,10 +307,11 @@ void ObjectRenderer::renderVehicle(VehicleObject* vehicle,
 
 void ObjectRenderer::renderPickup(PickupObject* pickup, RenderList& outList) {
     if (!pickup->isEnabled()) return;
-
+    
+    static constexpr float kRotationSpeedCoeff = 3.0f;
     glm::mat4 modelMatrix =
         glm::translate(glm::mat4(1.0f), pickup->getPosition());
-    modelMatrix = glm::rotate(modelMatrix, m_world->getGameTime(),
+    modelMatrix = glm::rotate(modelMatrix, m_world->getGameTime() * kRotationSpeedCoeff,
                               glm::vec3(0.f, 0.f, 1.f));
 
     auto odata = pickup->getModelInfo<SimpleModelInfo>();
diff --git a/rwgame/states/IngameState.cpp b/rwgame/states/IngameState.cpp
index 8a6d278ba..c1c23da54 100644
--- a/rwgame/states/IngameState.cpp
+++ b/rwgame/states/IngameState.cpp
@@ -18,6 +18,9 @@
 #include <objects/PickupObject.hpp>
 #include <objects/VehicleObject.hpp>
 #include <script/ScriptMachine.hpp>
+#include <audio/SoundEffect.hpp>
+#include <audio/EffectSlot.hpp>
+#include <audio/ReverbEffect.hpp>
 
 #include <glm/gtc/constants.hpp>
 #include <glm/gtx/matrix_major_storage.hpp>