Rewrote OpenAL, SoundManager, added system folder

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20141201 ]
+    * Moved Font, Sound, Window modules into system subfolder
+    * Rewrote OpenAL sound implementation, separated sourcing and buffering
+    * LoaderTR2 loads all sound-related data into SoundManager
+
     [ 20141129 ]
     * LoaderTR2 now supports loading animated textiles
     * Clearing textures and textiles before loading a new level

include/Sound.h

-/*!
- * \file include/Sound.h
- * \brief This is the audio manager Header
- *
- * \author Mongoose
- * \author xythobuz
- */
-
-#ifndef _SOUND_H_
-#define _SOUND_H_
-
-/*!
- * \brief This is the audio manager for OpenRaider
- */
-class Sound {
-  public:
-
-    typedef enum {
-        SoundFlagsNone = 0,       //!< No effect
-        SoundFlagsLoop = (1 << 0) //!< Enable looping during playback
-    } SoundFlags;
-
-    /*!
-     * \brief Deconstructs an object of Sound
-     */
-    virtual ~Sound();
-
-    /*!
-     * \brief Initialize sound system
-     * \returns 0 on success or < 0 error flags
-     */
-    virtual int initialize() = 0;
-
-    virtual void setEnabled(bool on) = 0;
-
-    virtual bool getEnabled() = 0;
-
-    /*!
-     * \brief Set the volume
-     * \param vol new source gain
-     */
-    virtual void setVolume(float vol) = 0;
-
-    virtual float getVolume() = 0;
-
-    /*!
-     * \brief Get number of registered sources
-     * \returns number of registered sources
-     */
-    virtual unsigned long registeredSources() = 0;
-
-    /*!
-     * \brief Remove all loaded sounds
-     */
-    virtual void clear() = 0;
-
-    /*!
-     * \brief Move listener and repositions them
-     * \param pos New position for listener
-     * \param angle New orientation for listener
-     */
-    virtual void listenAt(float pos[3], float angle[3]) = 0;
-
-    /*!
-     * \brief Move sound source to position
-     * \param source valid source id
-     * \param pos new position for source
-     */
-    virtual void sourceAt(unsigned long source, float pos[3]) = 0;
-
-    /*!
-     * \brief Load wav file from disk
-     * \param filename not NULL!
-     * \param source not NULL! Returns new source ID or -1 on error.
-     * \param flags set options. Use SoundFlags enum bitwise OR-ed
-     * \returns 0 for no error or < 0 error flag
-     */
-    virtual int addFile(const char* filename, unsigned long* source, unsigned int flags) = 0;
-
-    /*!
-     * \brief Load wav file from buffer
-     * \param wav not NULL! Is a valid waveform buffer!
-     * \param length length of wav buffer
-     * \param source not NULL! Returns new source ID or -1 on error.
-     * \param flags set options. Use SoundFlags enum bitwise OR-ed
-     * \returns 0 for no error or < 0 error flag
-     */
-    virtual int addWave(unsigned char* wav, unsigned int length, unsigned long* source,
-                        unsigned int flags) = 0;
-
-    /*!
-     * \brief Play sound source
-     * \param source sound source to play
-     */
-    virtual void play(unsigned long source) = 0;
-
-    /*!
-     * \brief Stop playing sound source
-     * \param source sound source to stop
-     */
-    virtual void stop(unsigned long source) = 0;
-};
-
-Sound& getSound();
-
-#endif
-

include/SoundAL.h

-/*!
- * \file include/SoundAL.h
- * \brief This is the OpenAL audio manager Header
- *
- * \author Mongoose
- * \author xythobuz
- */
-
-#ifndef _SOUND_AL_H_
-#define _SOUND_AL_H_
-
-#include <vector>
-
-#include "Sound.h"
-
-/*!
- * \brief This is the OpenAL audio manager
- */
-class SoundAL : public Sound {
-  public:
-
-    /*!
-     * \brief Constructs an object of SoundAL
-     */
-    SoundAL();
-
-    /*!
-     * \brief Deconstructs an object of SoundAL
-     */
-    virtual ~SoundAL();
-
-    /*!
-     * \brief Initialize sound system
-     * \returns 0 on success or < 0 error flags
-     */
-    virtual int initialize();
-
-    virtual void setEnabled(bool on);
-
-    virtual bool getEnabled() { return mEnabled; }
-
-    /*!
-     * \brief Set the volume
-     * \param vol new source gain
-     */
-    virtual void setVolume(float vol);
-
-    virtual float getVolume() { return mVolume; }
-
-    /*!
-     * \brief Get number of registered sources
-     * \returns number of registered sources
-     */
-    virtual unsigned long registeredSources();
-
-    /*!
-     * \brief Remove all loaded sounds
-     */
-    virtual void clear();
-
-    /*!
-     * \brief Move listener and repositions them
-     * \param pos New position for listener
-     * \param angle New orientation for listener
-     */
-    virtual void listenAt(float pos[3], float angle[3]);
-
-    /*!
-     * \brief Move sound source to position
-     * \param source valid source id
-     * \param pos new position for source
-     */
-    virtual void sourceAt(unsigned long source, float pos[3]);
-
-    /*!
-     * \brief Load wav file from disk
-     * \param filename not NULL!
-     * \param source not NULL! Returns new source ID or -1 on error.
-     * \param flags set options. Use SoundFlags enum bitwise OR-ed
-     * \returns 0 for no error or < 0 error flag
-     */
-    virtual int addFile(const char* filename, unsigned long* source, unsigned int flags);
-
-    /*!
-     * \brief Load wav file from buffer
-     * \param wav not NULL! Is a valid waveform buffer!
-     * \param length length of wav buffer
-     * \param source not NULL! Returns new source ID or -1 on error.
-     * \param flags set options. Use SoundFlags enum bitwise OR-ed
-     * \returns 0 for no error or < 0 error flag
-     */
-    virtual int addWave(unsigned char* wav, unsigned int length, unsigned long* source,
-                        unsigned int flags);
-
-    /*!
-     * \brief Play sound source
-     * \param source sound source to play
-     */
-    virtual void play(unsigned long source);
-
-    /*!
-     * \brief Stop playing sound source
-     * \param source sound source to stop
-     */
-    virtual void stop(unsigned long source);
-
-  private:
-
-    bool mEnabled;
-    bool mInit;                         //!< Guard to ensure ausio system is active
-    float mVolume;                      //!< Listener gain
-    std::vector<unsigned int> mBuffer; //!< Audio buffer id list
-    std::vector<unsigned int> mSource; //!< Audio source id list
-};
-
-#endif
-

include/SoundManager.h

 
 class SoundManager {
   public:
-    void clear();
-    void addSoundSource(float x, float y, float z, int id, int flags);
-    void addSoundMapEntry(int id);
-    void addSoundDetail(int sample, float volume);
-    void addSampleIndex(int index);
+    static void clear();
+    static int prepareSources();
 
-    int playSound(int index);
+    static void addSoundSource(float x, float y, float z, int id, int flags);
+    static void addSoundMapEntry(int id);
+    static void addSoundDetail(int sample, float volume);
+    static void addSampleIndex(int index);
+
+    static int sizeSoundMap();
+
+    static int getIndex(int index, float* volume = nullptr);
+
+    // index --> SoundMap --> SoundDetails --> SampleIndices --> play
+    static int playSound(int index);
 
   private:
-    std::vector<SoundSource> soundSources;
-    std::vector<int> soundMap;
-    std::vector<SoundDetail> soundDetails;
-    std::vector<int> sampleIndices;
+    static std::vector<SoundSource> soundSources;
+    static std::vector<int> soundMap;
+    static std::vector<SoundDetail> soundDetails;
+    static std::vector<int> sampleIndices;
 };
 
-SoundManager& getSoundManager();
-
 #endif
 

include/SoundNull.h

-/*!
- * \file include/SoundNull.h
- * \brief This is the null audio manager Header
- *
- * \author xythobuz
- */
-
-#ifndef _SOUND_NULL_H_
-#define _SOUND_NULL_H_
-
-#include "Sound.h"
-
-/*!
- * \brief This is the null audio manager
- */
-class SoundNull : public Sound {
-  public:
-
-    /*!
-     * \brief Constructs an object of SoundNull
-     */
-    SoundNull();
-
-    /*!
-     * \brief Deconstructs an object of SoundNull
-     */
-    virtual ~SoundNull();
-
-    /*!
-     * \brief Initialize sound system
-     * \returns 0 on success or < 0 error flags
-     */
-    virtual int initialize();
-
-    virtual void setEnabled(bool on);
-
-    virtual bool getEnabled() { return false; }
-
-    /*!
-     * \brief Set the volume
-     * \param vol new source gain
-     */
-    virtual void setVolume(float vol);
-
-    virtual float getVolume() { return 0.0f; }
-
-    /*!
-     * \brief Get number of registered sources
-     * \returns number of registered sources
-     */
-    virtual unsigned long registeredSources();
-
-    /*!
-     * \brief Remove all loaded sounds
-     */
-    virtual void clear();
-
-    /*!
-     * \brief Move listener and repositions them
-     * \param pos New position for listener
-     * \param angle New orientation for listener
-     */
-    virtual void listenAt(float pos[3], float angle[3]);
-
-    /*!
-     * \brief Move sound source to position
-     * \param source valid source id
-     * \param pos new position for source
-     */
-    virtual void sourceAt(unsigned long source, float pos[3]);
-
-    /*!
-     * \brief Load wav file from disk
-     * \param filename not NULL!
-     * \param source not NULL! Returns new source ID or -1 on error.
-     * \param flags set options. Use SoundFlags enum bitwise OR-ed
-     * \returns 0 for no error or < 0 error flag
-     */
-    virtual int addFile(const char* filename, unsigned long* source, unsigned int flags);
-
-    /*!
-     * \brief Load wav file from buffer
-     * \param wav not NULL! Is a valid waveform buffer!
-     * \param length length of wav buffer
-     * \param source not NULL! Returns new source ID or -1 on error.
-     * \param flags set options. Use SoundFlags enum bitwise OR-ed
-     * \returns 0 for no error or < 0 error flag
-     */
-    virtual int addWave(unsigned char* wav, unsigned int length, unsigned long* source,
-                        unsigned int flags);
-
-    /*!
-     * \brief Play sound source
-     * \param source sound source to play
-     */
-    virtual void play(unsigned long source);
-
-    /*!
-     * \brief Stop playing sound source
-     * \param source sound source to stop
-     */
-    virtual void stop(unsigned long source);
-
-  private:
-    unsigned long sources;
-};
-
-#endif
-

include/system/Sound.h

+/*!
+ * \file include/system/Sound.h
+ * \brief This is the audio manager Header
+ *
+ * \author xythobuz
+ */
+
+#ifndef _SOUND_H_
+#define _SOUND_H_
+
+class Sound {
+  public:
+    static int initialize();
+    static void shutdown();
+    static void clear();
+
+    static int numBuffers();
+    static int loadBuffer(unsigned char* buffer, unsigned int length);
+
+    static int numSources(bool atListener = false);
+    static int addSource(int buffer, float volume = 1.0f, bool atListener = false, bool loop = false);
+
+    static int sourceAt(int source, float pos[3]);
+    static void listenAt(float pos[3], float orientation[6]);
+
+    static void play(int source, bool atListener = false);
+    static void stopAll();
+
+    static void setEnabled(bool on = true);
+    static bool getEnabled();
+
+    static void setVolume(float vol = 1.0f);
+    static float getVolume();
+};
+
+#endif
+

include/system/SoundAL.h

+/*!
+ * \file include/system/SoundAL.h
+ * \brief This is the OpenAL audio manager Header
+ *
+ * \author xythobuz
+ */
+
+#ifndef _SOUND_AL_H_
+#define _SOUND_AL_H_
+
+#include <vector>
+
+class SoundAL {
+  public:
+    static int initialize();
+    static void shutdown();
+    static void clear();
+
+    static int numBuffers();
+    static int loadBuffer(unsigned char* buffer, unsigned int length);
+
+    static int numSources(bool atListener);
+    static int addSource(int buffer, float volume, bool atListener, bool loop);
+
+    static int sourceAt(int source, float pos[3]);
+    static void listenAt(float pos[3], float orientation[6]);
+
+    static void play(int source, bool atListener);
+    static void stopAll();
+
+    static void setEnabled(bool on);
+    static bool getEnabled();
+
+    static void setVolume(float vol);
+    static float getVolume();
+
+  private:
+    static bool init;
+    static bool enabled;
+    static float volume;
+
+    static std::vector<unsigned int> buffers;
+    static std::vector<unsigned int> sources;
+    static std::vector<unsigned int> listenerSources;
+
+    static float lastPosition[3];
+};
+
+#endif
+

include/WindowGLUT.h → include/system/WindowGLUT.h

 #ifndef _WINDOW_GLUT_H_
 #define _WINDOW_GLUT_H_
 
-#include "Window.h"
+#include "system/Window.h"
 
 /*!
  * \brief GLUT windowing implementation

include/WindowSDL.h → include/system/WindowSDL.h

 
 #include "SDL.h"
 
-#include "Window.h"
+#include "system/Window.h"
 
 /*!
  * \brief SDL windowing implementation

src/CMakeLists.txt

 set (SRCS ${SRCS} "Console.cpp")
 set (SRCS ${SRCS} "Entity.cpp")
 set (SRCS ${SRCS} "Exception.cpp")
-set (SRCS ${SRCS} "Font.cpp")
-set (SRCS ${SRCS} "FontImGui.cpp")
-set (SRCS ${SRCS} "FontTRLE.cpp")
 set (SRCS ${SRCS} "Game.cpp")
 set (SRCS ${SRCS} "Log.cpp")
 set (SRCS ${SRCS} "main.cpp")
 set (SRCS ${SRCS} "RunTime.cpp")
 set (SRCS ${SRCS} "Script.cpp")
 set (SRCS ${SRCS} "SkeletalModel.cpp")
-set (SRCS ${SRCS} "Sound.cpp")
 set (SRCS ${SRCS} "SoundManager.cpp")
 set (SRCS ${SRCS} "Sprite.cpp")
 set (SRCS ${SRCS} "StaticMesh.cpp")
 set (SRCS ${SRCS} "TombRaider.cpp")
 set (SRCS ${SRCS} "UI.cpp")
 set (SRCS ${SRCS} "ViewVolume.cpp")
-set (SRCS ${SRCS} "Window.cpp")
 set (SRCS ${SRCS} "World.cpp")
 
 # Select available Sound library
 if (OPENAL_FOUND AND ALUT_FOUND AND ENABLE_AUDIO)
-    set (SRCS ${SRCS} "SoundAL.cpp")
     set (USING_AL TRUE)
 else (OPENAL_FOUND AND ALUT_FOUND AND ENABLE_AUDIO)
-    set (SRCS ${SRCS} "SoundNull.cpp")
     set (USING_AL FALSE)
     message (STATUS "Disabled Sound support (no OpenAL and ALUT)!")
 endif (OPENAL_FOUND AND ALUT_FOUND AND ENABLE_AUDIO)
 
 # Select available Windowing library
 if (SDL2_FOUND AND NOT FORCE_GLUT)
-    set (SRCS ${SRCS} "WindowSDL.cpp")
     set (OpenRaider_CXX_FLAGS "${OpenRaider_CXX_FLAGS} -DUSING_SDL")
     if (SDL2TTF_FOUND)
-        set (SRCS ${SRCS} "FontSDL.cpp")
         set (OpenRaider_CXX_FLAGS "${OpenRaider_CXX_FLAGS} -DUSING_SDL_FONT")
     endif (SDL2TTF_FOUND)
 else (SDL2_FOUND AND NOT FORCE_GLUT)
     if (FREEGLUT_FOUND)
-        set (SRCS ${SRCS} "WindowGLUT.cpp")
         set (OpenRaider_CXX_FLAGS "${OpenRaider_CXX_FLAGS} -DUSING_GLUT")
     else (FREEGLUT_FOUND)
         message (FATAL_ERROR "SDL2 or freeGLUT are required!")
 add_subdirectory ("deps")
 add_subdirectory ("loader")
 add_subdirectory ("math")
+add_subdirectory ("system")
 add_subdirectory ("utils")
 
 # Add Executable
     $<TARGET_OBJECTS:OpenRaider_all> $<TARGET_OBJECTS:OpenRaider_commands>
     $<TARGET_OBJECTS:OpenRaider_deps> $<TARGET_OBJECTS:OpenRaider_math>
     $<TARGET_OBJECTS:OpenRaider_utils> $<TARGET_OBJECTS:OpenRaider_loader>
+    $<TARGET_OBJECTS:OpenRaider_system>
 )
 
 #################################################################

src/Game.cpp

 #include "loader/Loader.h"
 #include "Log.h"
 #include "Render.h"
-#include "Sound.h"
 #include "SoundManager.h"
 #include "StaticMesh.h"
+#include "system/Sound.h"
 #include "TextureManager.h"
 #include "World.h"
 #include "utils/strings.h"
 
     getWorld().destroy();
     getRender().ClearWorld();
-    getSound().clear(); // Remove all previously loaded sounds
-    getSoundManager().clear();
+    Sound::clear(); // Remove all previously loaded sounds
+    SoundManager::clear();
     getTextureManager().clear();
 }
 
         if (error != 0) {
             getLog() << "Error while trying new loader (" << error << ")..." << Log::endl;
             destroy();
+        } else {
+            SoundManager::prepareSources();
         }
     }
 
     for (i = 0; i < mTombRaider.getSoundSamplesCount(); ++i) {
         mTombRaider.getSoundSample(i, &riffSz, &riff);
 
-        getSound().addWave(riff, riffSz, &id, Sound::SoundFlagsNone);
+        id = Sound::loadBuffer(riff, riffSz);
 
         //if (((i + 1) == TR_SOUND_F_PISTOL) && (id > 0))
         //{

src/Menu.cpp

  */
 
 #include "global.h"
-#include "Font.h"
 #include "Log.h"
-#include "Window.h"
 #include "Menu.h"
 #include "MenuFolder.h"
+#include "system/Font.h"
+#include "system/Window.h"
 
 void Menu::showDialog(std::string msg, std::string btn1, std::string btn2,
                       std::function<int (bool state)> callback) {

src/MenuFolder.cpp

  */
 
 #include "global.h"
-#include "Font.h"
 #include "Game.h"
 #include "loader/Loader.h"
 #include "Log.h"
 #include "RunTime.h"
-#include "Window.h"
 #include "MenuFolder.h"
+#include "system/Font.h"
+#include "system/Window.h"
 
 MenuFolder::MenuFolder() {
     mCursor = 0;

src/Render.cpp

 #include "Render.h"
 #include "utils/strings.h"
 #include "utils/tga.h"
-#include "Window.h"
 #include "World.h"
+#include "system/Window.h"
 
 Render::Render() {
     mSkyMesh = -1;

src/Sound.cpp

-/*!
- * \file src/Sound.cpp
- * \brief This is the audio manager Implementation
- *
- * \author xythobuz
- */
-
-#include "global.h"
-#include "Sound.h"
-
-Sound::~Sound() {
-}
-

src/SoundAL.cpp

-/*!
- * \file src/SoundAL.cpp
- * \brief This is the OpenAL audio manager Implementation
- *
- * \author Mongoose
- * \author xythobuz
- */
-
-#ifdef __APPLE__
-#include <OpenAL/al.h>
-#else
-#include <AL/al.h>
-#include <fcntl.h>
-#include <unistd.h>
-#endif
-
-#include <AL/alut.h>
-
-#include <cstdio>
-#include <cstdlib>
-
-#include "global.h"
-#include "math/math.h"
-#include "SoundAL.h"
-
-SoundAL::SoundAL() {
-    mEnabled = false;
-    mInit = false;
-    mVolume = 1.0f;
-}
-
-SoundAL::~SoundAL() {
-    if (mInit)
-        alutExit();
-}
-
-int SoundAL::initialize() {
-    assert(mInit == false);
-
-    if (!mEnabled)
-        return 0;
-
-    ALCdevice* Device = alcOpenDevice(NULL);
-    ALCcontext* Context = alcCreateContext(Device, NULL);
-    alcMakeContextCurrent(Context);
-
-    if (alutInitWithoutContext(NULL, NULL) == AL_FALSE) {
-        printf("ALUT-Error: %s\n", alutGetErrorString(alutGetError()));
-        return -2;
-    }
-
-    mInit = true;
-
-    return 0;
-}
-
-void SoundAL::setEnabled(bool on) {
-    mEnabled = on;
-    if (on && (!mInit))
-        initialize();
-}
-
-void SoundAL::setVolume(float vol) {
-    assert(mSource.size() == mBuffer.size());
-
-    if (mEnabled) {
-        if ((mSource.size() > 0) && (!equalEpsilon(mVolume, vol))) {
-            // Apply new volume to old sources if needed
-            for (size_t i = 0; i < mSource.size(); i++)
-                alSourcef(mSource[i], AL_GAIN, vol);
-        }
-    }
-
-    mVolume = vol;
-}
-
-unsigned long SoundAL::registeredSources() {
-    assert(mSource.size() == mBuffer.size());
-
-    if ((!mEnabled) || (!mInit))
-        return 0;
-
-    return mSource.size();
-}
-
-void SoundAL::clear() {
-    assert(mSource.size() == mBuffer.size());
-
-    if ((!mEnabled) || (!mInit))
-        return;
-
-    for (size_t i = 0; i < mSource.size(); i++) {
-        alDeleteSources(1, &mSource[i]);
-        alDeleteBuffers(1, &mBuffer[i]);
-    }
-
-    mSource.clear();
-    mBuffer.clear();
-}
-
-void SoundAL::listenAt(float pos[3], float angle[3]) {
-    assert(mSource.size() == mBuffer.size());
-    assert(pos != NULL);
-    assert(angle != NULL);
-
-    if ((!mEnabled) || (!mInit))
-        return;
-
-    alListenerfv(AL_POSITION, pos);
-    alListenerfv(AL_ORIENTATION, angle);
-}
-
-void SoundAL::sourceAt(unsigned long source, float pos[3]) {
-    assert(mSource.size() == mBuffer.size());
-    assert(source < mSource.size());
-    assert(pos != NULL);
-
-    if ((!mEnabled) || (!mInit))
-        return;
-
-    alSourcefv(mSource[source], AL_POSITION, pos);
-}
-
-//! \fixme Seperate sourcing and buffering, Mongoose 2002.01.04
-int SoundAL::addFile(const char* filename, unsigned long* source, unsigned int flags) {
-    ALsizei size;
-    ALfloat freq;
-    ALenum format;
-    ALvoid* data;
-    unsigned long id;
-
-    assert(mSource.size() == mBuffer.size());
-    assert(filename != NULL);
-    assert(filename[0] != '\0');
-    assert(source != NULL);
-
-    if ((!mEnabled) || (!mInit)) {
-        *source = 0;
-        return 0;
-    }
-
-    id = mSource.size();
-
-    mSource.push_back(0);
-    mBuffer.push_back(0);
-
-    alGetError();
-    alGenBuffers(1, &mBuffer[id]);
-    if (alGetError() != AL_NO_ERROR) {
-        printf("Could not load wav file (alGenBuffers)\n");
-        return -1;
-    }
-
-    alGetError();
-    alGenSources(1, &mSource[id]);
-    if (alGetError() != AL_NO_ERROR) {
-        printf("Could not load wav file (alGenSources)\n");
-        return -2;
-    }
-
-    data = alutLoadMemoryFromFile(filename, &format, &size, &freq);
-    if (alutGetError() != ALUT_ERROR_NO_ERROR) {
-        printf("Could not load %s\n", filename);
-        return -3;
-    }
-
-    alBufferData(mBuffer[id], format, data, size, static_cast<ALsizei>(freq));
-    alSourcei(mSource[id], AL_BUFFER, mBuffer[id]);
-
-    if (flags & SoundFlagsLoop) {
-        alSourcei(mSource[id], AL_LOOPING, 1);
-    }
-
-    alSourcef(mSource[id], AL_GAIN, mVolume);
-
-    *source = id;
-
-    return 0;
-}
-
-int SoundAL::addWave(unsigned char* wav, unsigned int length, unsigned long* source,
-                     unsigned int flags) {
-    ALsizei size;
-    ALfloat freq;
-    ALenum format;
-    ALvoid* data;
-    int error = 0;
-    unsigned long id;
-
-    assert(mSource.size() == mBuffer.size());
-    assert(wav != NULL);
-    assert(source != NULL);
-
-    if ((!mEnabled) || (!mInit)) {
-        *source = 0;
-        return 0;
-    }
-
-    id = mSource.size();
-
-    mSource.push_back(0);
-    mBuffer.push_back(0);
-
-    data = wav;
-
-    alGetError();
-    alGenBuffers(1, &mBuffer[id]);
-    if (alGetError() != AL_NO_ERROR) {
-        printf("Could not load wav (alGenBuffers)\n");
-        return -1;
-    }
-
-    alGetError();
-    alGenSources(1, &mSource[id]);
-    if (alGetError() != AL_NO_ERROR) {
-        printf("Could not load wav (alGenSources)\n");
-        return -2;
-    }
-
-    data = alutLoadMemoryFromFileImage(wav, length, &format, &size, &freq);
-    if (((error = alutGetError()) != ALUT_ERROR_NO_ERROR) || (data == NULL)) {
-        printf("Could not load wav buffer (%s)\n", alutGetErrorString(error));
-        return -3;
-    }
-
-    alBufferData(mBuffer[id], format, data, size, static_cast<ALsizei>(freq));
-    alSourcei(mSource[id], AL_BUFFER, mBuffer[id]);
-
-    if (flags & SoundFlagsLoop) {
-        alSourcei(mSource[id], AL_LOOPING, 1);
-    }
-
-    alSourcef(mSource[id], AL_GAIN, mVolume);
-
-    *source = id;
-
-    //! \fixme Should free alut buffer?
-
-    return 0;
-}
-
-void SoundAL::play(unsigned long source) {
-    assert(mInit);
-    assert(mSource.size() == mBuffer.size());
-    assert(source < mSource.size());
-
-    if (!mEnabled)
-        return;
-
-    alSourcePlay(mSource[source]);
-}
-
-void SoundAL::stop(unsigned long source) {
-    assert(mInit);
-    assert(mSource.size() == mBuffer.size());
-    assert(source < mSource.size());
-
-    if (!mEnabled)
-        return;
-
-    alSourceStop(mSource[source]);
-}
-

src/SoundManager.cpp

  */
 
 #include "global.h"
-#include "Sound.h"
+#include "system/Sound.h"
 #include "SoundManager.h"
 
+std::vector<SoundSource> SoundManager::soundSources;
+std::vector<int> SoundManager::soundMap;
+std::vector<SoundDetail> SoundManager::soundDetails;
+std::vector<int> SoundManager::sampleIndices;
+
 void SoundManager::clear() {
     soundSources.clear();
     soundMap.clear();
     sampleIndices.clear();
 }
 
+int SoundManager::prepareSources() {
+    for (int i = 0; i < soundSources.size(); i++) {
+        float vol;
+        int index = getIndex(soundSources.at(i).id, &vol);
+        int ret = Sound::addSource(index, vol, false, true);
+        assert(ret == i);
+        float pos[3] = { soundSources.at(i).x, soundSources.at(i).y, soundSources.at(i).z };
+        ret = Sound::sourceAt(i, pos);
+        assert(ret == 0);
+        Sound::play(i, false);
+    }
+
+    for (int i = 0; i < soundMap.size(); i++) {
+        float vol;
+        int index = getIndex(i, &vol);
+        if (index >= 0) {
+            int ret = Sound::addSource(index, vol, true, false);
+            assert(ret >= 0);
+        }
+    }
+}
+
 void SoundManager::addSoundSource(float x, float y, float z, int id, int flags) {
     soundSources.emplace_back(x, y, z, id, flags);
 }
     sampleIndices.push_back(index);
 }
 
-int SoundManager::playSound(int index) {
+int SoundManager::sizeSoundMap() {
+    return soundMap.size();
+}
+
+int SoundManager::getIndex(int index, float* volume) {
+    if (index <= -1)
+        return -1;
+
     if (index >= soundMap.size())
-        return -1; // SoundMap not big enough
+        return -2; // SoundMap not big enough
 
     index = soundMap.at(index);
 
-    if (index == -1)
-        return -2; // SoundMap has no entry here (-1)
+    if (index <= -1)
+        return -3; // SoundMap has no entry here (-1)
 
     if (index >= soundDetails.size())
-        return -3; // SoundMap entry is bigger than SoundDetails
+        return -4; // SoundMap entry is bigger than SoundDetails
 
     SoundDetail s = soundDetails.at(index);
 
-    if (s.sample == -1)
-        return -4; // SoundDetail has no entry here (-1)
+    if (volume != nullptr)
+        *volume = s.volume;
+
+    if (s.sample <= -1)
+        return -5; // SoundDetail has no entry here (-1)
 
     if (s.sample >= sampleIndices.size())
-        return -5; // SoundDetail entry is bigger than SampleIndices
+        return -6; // SoundDetail entry is bigger than SampleIndices
 
     index = sampleIndices.at(s.sample);
 
-    if (index == -1)
-        return -6; // SampleIndices has no entry here (-1)
-
-    if (index >= getSound().registeredSources())
-        return -7; // SampleIndices entry is bigger than number of sounds loaded
+    if (index <= -1)
+        return -7; // SampleIndices has no entry here (-1)
 
-    // TODO play sound _index_ with matching volume
+    return index;
+}
 
-    return 0;
+int SoundManager::playSound(int index) {
+    if ((index >= 0) && (index < soundMap.size())) {
+        if (soundMap.at(index) == -1)
+            return 0;
+
+        int c = 1;
+        for (int i = 0; i < index; i++)
+            if (soundMap.at(i) != -1)
+                c++;
+
+        Sound::play(c, true);
+        return 0;
+    } else {
+        return -1;
+    }
 }
 

src/SoundNull.cpp

-/*!
- * \file src/SoundNull.cpp
- * \brief This is the null audio manager Implementation
- *
- * \author xythobuz
- */
-
-#include "global.h"
-#include "SoundNull.h"
-
-SoundNull::SoundNull() {
-    sources = 0;
-}
-
-SoundNull::~SoundNull() {
-}
-
-int SoundNull::initialize() {
-    return 0;
-}
-
-void SoundNull::setEnabled(bool on) {
-}
-
-void SoundNull::setVolume(float vol) {
-}
-
-unsigned long SoundNull::registeredSources() {
-    return sources;
-}
-
-void SoundNull::clear() {
-    sources = 0;
-}
-
-void SoundNull::listenAt(float pos[3], float angle[3]) {
-}
-
-void SoundNull::sourceAt(unsigned long source, float pos[3]) {
-    assert(source < sources);
-}
-
-int SoundNull::addFile(const char* filename, unsigned long* source, unsigned int flags) {
-    *source = sources;
-    sources++;
-    return 0;
-}
-
-int SoundNull::addWave(unsigned char* wav, unsigned int length, unsigned long* source,
-                       unsigned int flags) {
-    *source = sources;
-    sources++;
-    return 0;
-}
-
-void SoundNull::play(unsigned long source) {
-    assert(source < sources);
-}
-
-void SoundNull::stop(unsigned long source) {
-    assert(source < sources);
-}
-

src/UI.cpp

 #include "Menu.h"
 #include "Render.h"
 #include "RunTime.h"
-#include "Sound.h"
+#include "SoundManager.h"
 #include "TextureManager.h"
-#include "Window.h"
 #include "commands/Command.h"
+#include "system/Sound.h"
+#include "system/Window.h"
 #include "utils/time.h"
 #include "UI.h"
 
     bool input = !(visible || getMenu().isVisible());
     if (getWindow().getMousegrab() != input)
         getWindow().setMousegrab(input);
+
+    io.MouseWheel = 0;
 }
 
 void UI::display() {
                 getRunTime().setRunning(running);
             }
             ImGui::SameLine();
-            bool sound = getSound().getEnabled();
+            bool sound = Sound::getEnabled();
             if (ImGui::Checkbox("Sound##runtime", &sound)) {
-                getSound().setEnabled(sound);
+                Sound::setEnabled(sound);
             }
             ImGui::SameLine();
             bool fullscreen = getWindow().getFullscreen();
                 getWindow().setFullscreen(fullscreen);
             }
 
-            float vol = getSound().getVolume();
+            float vol = Sound::getVolume();
             if (ImGui::InputFloat("Volume##runtime", &vol, 0.0f, 0.0f, 3,
                                   ImGuiInputTextFlags_EnterReturnsTrue)) {
                 if (vol < 0.0f)
                     vol = 0.0f;
                 if (vol > 1.0f)
                     vol = 1.0f;
-                getSound().setVolume(vol);
+                Sound::setVolume(vol);
             }
 
             int w = getWindow().getWidth();
             }
         }
 
-        if (ImGui::CollapsingHeader("SoundSample Player")) {
-            if (!getSound().getEnabled()) {
-                ImGui::Text("Please enable Sound before loading a level!");
+        if (ImGui::CollapsingHeader("SoundManager Player")) {
+            if (!Sound::getEnabled()) {
+                ImGui::Text("Please enable Sound first!");
                 if (ImGui::Button("Enable Sound!")) {
-                    getSound().setEnabled(true);
+                    Sound::setEnabled(true);
                 }
-            } else if (getSound().registeredSources() == 0) {
+            } else if (Sound::numBuffers() == 0) {
                 ImGui::Text("Please load a level!");
             } else {
                 static int index = 0;
                 ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.5f);
-                ImGui::SliderInt("##soundslide", &index, 0, getSound().registeredSources() - 1);
+                ImGui::SliderInt("##soundslide", &index, 0, SoundManager::sizeSoundMap() - 1);
                 ImGui::PopItemWidth();
                 ImGui::SameLine();
                 if (ImGui::Button("+##soundplus", ImVec2(0, 0), true)) {
-                    if (index < (getSound().registeredSources() - 1))
+                    if (index < (SoundManager::sizeSoundMap() - 1))
                         index++;
                     else
                         index = 0;
                     if (index > 0)
                         index--;
                     else
-                        index = getSound().registeredSources() - 1;
+                        index = SoundManager::sizeSoundMap() - 1;
                 }
                 ImGui::SameLine();
                 if (ImGui::Button("Play##soundplay")) {
-                    getSound().play(index);
+                    SoundManager::playSound(index);
                 }
+
+                ImGui::Text("Index: %d", SoundManager::getIndex(index));
             }
         }
 
 
 void UI::handleMouseScroll(int xrel, int yrel) {
     ImGuiIO& io = ImGui::GetIO();
-    io.MouseWheel = (yrel != 0) ? yrel > 0 ? 1 : -1 : 0;
+    io.MouseWheel += yrel;
 
     scrollEvents.push_back(std::make_tuple(xrel, yrel));
 }

src/commands/CommandSet.cpp

 
 #include "global.h"
 #include "Camera.h"
-#include "Font.h"
 #include "Log.h"
 #include "RunTime.h"
-#include "Sound.h"
-#include "Window.h"
+#include "system/Font.h"
+#include "system/Sound.h"
+#include "system/Window.h"
 #include "utils/strings.h"
 #include "commands/CommandSet.h"
 
             getLog() << "set-audio-Error: Invalid value" << Log::endl;
             return -4;
         }
-        getSound().setEnabled(audio);
+        Sound::setEnabled(audio);
     } else if (var.compare("volume") == 0) {
         float vol = 1.0f;
         if (!(args >> vol)) {
             getLog() << "set-volume-Error: Invalid value" << Log::endl;
             return -5;
         }
-        getSound().setVolume(vol);
+        Sound::setVolume(vol);
     } else if (var.compare("mouse_x") == 0) {
         float sense = 1.0f;
         if (!(args >> sense)) {
     } else if (var.compare("fullscreen") == 0) {
         getLog() << getWindow().getFullscreen() << Log::endl;
     } else if (var.compare("audio") == 0) {
-        getLog() << getSound().getEnabled() << Log::endl;
+        getLog() << Sound::getEnabled() << Log::endl;
     } else if (var.compare("volume") == 0) {
-        getLog() << getSound().getVolume() << Log::endl;
+        getLog() << Sound::getVolume() << Log::endl;
     } else if (var.compare("mouse_x") == 0) {
         getLog() << OR_RAD_TO_DEG(getCamera().getSensitivityX()) << Log::endl;
     } else if (var.compare("mouse_y") == 0) {

src/loader/LoaderTR2.cpp

 #include "Log.h"
 #include "Mesh.h"
 #include "Room.h"
-#include "Sound.h"
 #include "SoundManager.h"
 #include "TextureManager.h"
+#include "system/Sound.h"
 #include "utils/pixel.h"
 #include "loader/LoaderTR2.h"
 
         // Unknown, 0x40, 0x80 or 0xC0
         uint16_t flags = file.readU16();
 
-        getSoundManager().addSoundSource(x, y, z, soundID, flags);
+        SoundManager::addSoundSource(x, y, z, soundID, flags);
     }
+
+    if (numSoundSources > 0)
+        getLog() << "LoaderTR2: Found " << numSoundSources << " SoundSources" << Log::endl;
 }
 
 void LoaderTR2::loadSoundMap() {
     for (int i = 0; i < 370; i++) {
-        getSoundManager().addSoundMapEntry(file.read16());
+        SoundManager::addSoundMapEntry(file.read16());
     }
 }
 
         // Bits 0-1: channel number?
         uint16_t unknown2 = file.readU16();
 
-        getSoundManager().addSoundDetail(sample, ((float)volume) / 32767.0f);
+        SoundManager::addSoundDetail(sample, ((float)volume) / 32767.0f);
     }
+
+    if (numSoundDetails > 0)
+        getLog() << "LoaderTR2: Found " << numSoundDetails << " SoundDetails" << Log::endl;
 }
 
 void LoaderTR2::loadSampleIndices() {
     uint32_t numSampleIndices = file.readU32();
     for (unsigned int i = 0; i < numSampleIndices; i++) {
-        getSoundManager().addSampleIndex(file.readU32());
+        SoundManager::addSampleIndex(file.readU32());
     }
+
+    if (numSampleIndices > 0)
+        getLog() << "LoaderTR2: Found " << numSampleIndices << " SampleIndices" << Log::endl;
 }
 
 void LoaderTR2::loadExternalSoundFile(std::string f) {
             buff[i] = sfx.readU8();
 
         unsigned long src;
-        int ret = getSound().addWave(buff, riffSize + 8, &src, 0);
+        int ret = Sound::loadBuffer(buff, riffSize + 8);
         assert(ret >= 0);
 
         riffCount++;

src/main.cpp

 #ifndef UNIT_TEST
 
 #include "Camera.h"
-#include "Font.h"
 #include "Game.h"
 #include "Log.h"
 #include "MenuFolder.h"
 #include "SoundManager.h"
 #include "TextureManager.h"
 #include "UI.h"
-#include "Window.h"
 #include "World.h"
-
-#ifdef USING_AL
-#include "SoundAL.h"
-#else
-#include "SoundNull.h"
-#endif
+#include "system/Font.h"
+#include "system/Sound.h"
+#include "system/Window.h"
 
 #ifdef USING_SDL
-#include "WindowSDL.h"
+#include "system/WindowSDL.h"
 #elif defined(USING_GLUT)
-#include "WindowGLUT.h"
+#include "system/WindowGLUT.h"
 #else
 #error No Windowing Library selected!
 #endif
 static std::shared_ptr<MenuFolder> gMenu;
 static std::shared_ptr<Render> gRender;
 static std::shared_ptr<RunTime> gRunTime;
-static std::shared_ptr<Sound> gSound;
-static std::shared_ptr<SoundManager> gSoundManager;
 static std::shared_ptr<TextureManager> gTextureManager;
 static std::shared_ptr<Window> gWindow;
 static std::shared_ptr<World> gWorld;
     return *gRunTime;
 }
 
-Sound& getSound() {
-    return *gSound;
-}
-
-SoundManager& getSoundManager() {
-    return *gSoundManager;
-}
-
 TextureManager& getTextureManager() {
     return *gTextureManager;
 }
     gLog.reset(new Log());
     gMenu.reset(new MenuFolder());
     gRender.reset(new Render());
-    gSoundManager.reset(new SoundManager());
     gTextureManager.reset(new TextureManager());
     gWorld.reset(new World());
 
-#ifdef USING_AL
-    gSound.reset(new SoundAL());
-#else
-    gSound.reset(new SoundNull());
-#endif
-
 #ifdef USING_SDL
     gWindow.reset(new WindowSDL());
 #elif defined(USING_GLUT)
     }
 
     // Initialize Sound
-    error = getSound().initialize();
+    error = Sound::initialize();
     if (error != 0) {
         std::cout << "Could not initialize Sound (" << error << ")!" << std::endl;
         return -4;
 
     UI::shutdown();
     Font::shutdown();
+    Sound::shutdown();
 
 #ifdef DEBUG
     std::cout << std::endl;

src/system/CMakeLists.txt

+# Source files
+set (SYS_SRCS ${SYS_SRCS} "Font.cpp")
+set (SYS_SRCS ${SYS_SRCS} "FontImGui.cpp")
+set (SYS_SRCS ${SYS_SRCS} "FontTRLE.cpp")
+set (SYS_SRCS ${SYS_SRCS} "Sound.cpp")
+set (SYS_SRCS ${SYS_SRCS} "Window.cpp")
+
+# Select available Sound library
+if (OPENAL_FOUND AND ALUT_FOUND AND ENABLE_AUDIO)
+    set (SYS_SRCS ${SYS_SRCS} "SoundAL.cpp")
+else (OPENAL_FOUND AND ALUT_FOUND AND ENABLE_AUDIO)
+    message (STATUS "Disabled Sound support (no OpenAL and ALUT)!")
+endif (OPENAL_FOUND AND ALUT_FOUND AND ENABLE_AUDIO)
+
+# Select available Windowing library
+if (SDL2_FOUND AND NOT FORCE_GLUT)
+    set (SYS_SRCS ${SYS_SRCS} "WindowSDL.cpp")
+    if (SDL2TTF_FOUND)
+        set (SYS_SRCS ${SYS_SRCS} "FontSDL.cpp")
+    endif (SDL2TTF_FOUND)
+else (SDL2_FOUND AND NOT FORCE_GLUT)
+    if (FREEGLUT_FOUND)
+        set (SYS_SRCS ${SYS_SRCS} "WindowGLUT.cpp")
+    else (FREEGLUT_FOUND)
+        message (FATAL_ERROR "SDL2 or freeGLUT are required!")
+    endif (FREEGLUT_FOUND)
+endif (SDL2_FOUND AND NOT FORCE_GLUT)
+
+# Add library
+add_library (OpenRaider_system OBJECT ${SYS_SRCS})
+

src/Font.cpp → src/system/Font.cpp

 #include "global.h"
 #include "Log.h"
 #include "utils/strings.h"
-#include "Window.h"
-#include "Font.h"
-#include "FontImGui.h"
-#include "FontTRLE.h"
+#include "system/Window.h"
+#include "system/Font.h"
+#include "system/FontImGui.h"
+#include "system/FontTRLE.h"
 
 #ifdef USING_SDL_FONT
-#include "FontSDL.h"
+#include "system/FontSDL.h"
 #endif
 
 bool Font::isInit = false;

src/FontImGui.cpp → src/system/FontImGui.cpp

 
 #include "global.h"
 #include "UI.h"
-#include "FontImGui.h"
+#include "system/FontImGui.h"
 
 #define SCALE_CALC 1.0f
 #define SCALE_DRAW 20.0f

src/FontSDL.cpp → src/system/FontSDL.cpp

 #include <iostream>
 
 #include "global.h"
-#include "FontSDL.h"
+#include "system/FontSDL.h"
 
 bool FontSDL::mFontInit = false;
 TTF_Font* FontSDL::mFont = nullptr;

src/FontTRLE.cpp → src/system/FontTRLE.cpp

 
 #include "global.h"
 #include "utils/strings.h"
-#include "FontTRLE.h"
+#include "system/FontTRLE.h"
 
 #define SCALING 2.0f
 

src/system/Sound.cpp

+/*!
+ * \file src/system/Sound.cpp
+ * \brief This is the audio manager Implementation
+ *
+ * \author xythobuz
+ */
+
+#include "global.h"
+#include "system/Sound.h"
+
+#ifdef USING_AL
+#include "system/SoundAL.h"
+#endif
+
+int Sound::initialize() {
+#ifdef USING_AL
+    return SoundAL::initialize();
+#else
+    return 0;
+#endif
+}
+
+void Sound::shutdown() {
+#ifdef USING_AL
+    SoundAL::shutdown();
+#endif
+}
+
+void Sound::clear() {
+#ifdef USING_AL
+    SoundAL::clear();
+#endif
+}
+
+int Sound::numBuffers() {
+#ifdef USING_AL
+    return SoundAL::numBuffers();
+#else
+    return 0;
+#endif
+}
+
+int Sound::loadBuffer(unsigned char* buffer, unsigned int length) {
+#ifdef USING_AL
+    return SoundAL::loadBuffer(buffer, length);
+#else
+    return 0;
+#endif
+}
+
+int Sound::numSources(bool atListener) {
+#ifdef USING_AL
+    return SoundAL::numSources(atListener);
+#else
+    return 0;
+#endif
+}
+
+int Sound::addSource(int buffer, float volume, bool atListener, bool loop) {
+#ifdef USING_AL
+    return SoundAL::addSource(buffer, volume, atListener, loop);
+#else
+    return 0;
+#endif
+}
+
+int Sound::sourceAt(int source, float pos[3]) {
+#ifdef USING_AL
+    return SoundAL::sourceAt(source, pos);
+#else
+    return 0;
+#endif
+}
+
+void Sound::listenAt(float pos[3], float orientation[6]) {
+#ifdef USING_AL
+    SoundAL::listenAt(pos, orientation);
+#endif
+}
+
+void Sound::play(int source, bool atListener) {
+#ifdef USING_AL
+    SoundAL::play(source, atListener);
+#endif
+}
+
+void Sound::stopAll() {
+#ifdef USING_AL
+    SoundAL::stopAll();
+#endif
+}
+
+void Sound::setEnabled(bool on) {
+#ifdef USING_AL
+    SoundAL::setEnabled(on);
+#endif
+}
+
+bool Sound::getEnabled() {
+#ifdef USING_AL
+    return SoundAL::getEnabled();
+#else
+    return false;
+#endif
+}
+
+void Sound::setVolume(float vol) {
+#ifdef USING_AL
+    SoundAL::setVolume(vol);
+#endif
+}
+
+float Sound::getVolume() {
+#ifdef USING_AL
+    return SoundAL::getVolume();
+#else
+    return 0.0f;
+#endif
+}
+

src/system/SoundAL.cpp

+/*!
+ * \file src/system/SoundAL.cpp
+ * \brief This is the OpenAL audio manager Implementation
+ *
+ * \author Mongoose
+ * \author xythobuz
+ */
+
+#ifdef __APPLE__
+#include <OpenAL/al.h>
+#else
+#include <AL/al.h>
+#include <fcntl.h>
+#include <unistd.h>
+#endif
+
+#include <AL/alut.h>
+
+#include "global.h"
+#include "Log.h"
+#include "system/SoundAL.h"
+
+bool SoundAL::init = false;
+bool SoundAL::enabled = true;
+float SoundAL::volume = 1.0f;
+std::vector<unsigned int> SoundAL::buffers;
+std::vector<unsigned int> SoundAL::sources;
+std::vector<unsigned int> SoundAL::listenerSources;
+float SoundAL::lastPosition[3] = { 0.0f, 0.0f, 0.0f };
+
+int SoundAL::initialize() {
+    if (init)
+        return 0;
+
+    ALCdevice* device = alcOpenDevice(NULL);
+    ALCcontext* context = alcCreateContext(device, NULL);
+    alcMakeContextCurrent(context);
+
+    if (alutInitWithoutContext(nullptr, nullptr) == AL_FALSE) {
+        getLog() << "SoundAL Error: " << alutGetErrorString(alutGetError()) << Log::endl;
+        return -1;
+    }
+
+    init = true;
+    setVolume(volume);
+    return 0;
+}
+
+void SoundAL::shutdown() {
+    if (!init)
+        return;
+
+    clear();
+    if (alutExit() == AL_FALSE)
+        getLog() << "SoundAL Error: " << alutGetErrorString(alutGetError()) << Log::endl;
+    init = false;
+}
+
+void SoundAL::clear() {
+    if (!init)
+        return;
+
+    stopAll();
+
+    alGetError();
+    alDeleteSources(sources.size(), &sources[0]);
+    sources.clear();
+    if (alGetError() != AL_NO_ERROR) {
+        getLog() << "SoundAL: Error while deleting sources!" << Log::endl;
+    }
+
+    alGetError();
+    alDeleteSources(listenerSources.size(), &listenerSources[0]);
+    listenerSources.clear();
+    if (alGetError() != AL_NO_ERROR) {
+        getLog() << "SoundAL: Error while deleting listener sources!" << Log::endl;
+    }
+
+    alGetError();
+    alDeleteBuffers(buffers.size(), &buffers[0]);
+    if (alGetError() != AL_NO_ERROR) {
+        getLog() << "SoundAL: Error while deleting buffers!" << Log::endl;
+    }
+
+    for (int i = 0; i < 3; i++)
+        lastPosition[i] = 0.0f;
+}
+
+int SoundAL::numBuffers() {
+    return buffers.size();
+}
+
+int SoundAL::loadBuffer(unsigned char* buffer, unsigned int length) {
+    if (!init)
+        return -1;
+
+    alGetError();
+    unsigned int r = alutCreateBufferFromFileImage(buffer, length);
+    if (r == AL_NONE) {
+        getLog() << "SoundAL Error: " << alutGetErrorString(alutGetError()) << Log::endl;
+        return -2;
+    }
+    buffers.push_back(r);
+    return r;
+}
+
+int SoundAL::numSources(bool atListener) {
+    if (atListener)
+        return listenerSources.size();
+    else
+        return sources.size();
+}
+
+int SoundAL::addSource(int buffer, float volume, bool atListener, bool loop) {
+    if ((!init) || (buffer < 0) || (buffer >= buffers.size()))
+        return -1;
+
+    unsigned int id;
+
+    alGetError();
+    alGenSources(1, &id);
+    if (alGetError() != AL_NO_ERROR) {
+        getLog() << "SoundAL Error: Could not create source!" << Log::endl;
+        return -2;
+    }
+
+    alSourcei(id, AL_BUFFER, buffers.at(buffer));
+    alSourcef(id, AL_GAIN, volume);
+
+    if (loop)
+        alSourcei(id, AL_LOOPING, AL_TRUE);
+
+    if (atListener) {
+        alSourcefv(id, AL_POSITION, lastPosition);
+        listenerSources.push_back(id);
+        return listenerSources.size() - 1;
+    } else {
+        sources.push_back(id);
+        return sources.size() - 1;
+    }
+}
+
+int SoundAL::sourceAt(int source, float pos[3]) {
+    if (!init)
+        return -1;
+
+    if ((source < 0) || (source >= sources.size()) || (pos == nullptr)) {
+        getLog() << "SoundAL: Can't position non-existing source!" << Log::endl;
+        return -2;
+    }
+
+    alSourcefv(sources.at(source), AL_POSITION, pos);
+
+    return 0;
+}
+
+void SoundAL::listenAt(float pos[3], float orientation[6]) {
+    if ((!init) || (pos == nullptr) || (orientation == nullptr))
+        return;
+
+    alListenerfv(AL_POSITION, pos);
+    alListenerfv(AL_ORIENTATION, orientation);
+
+    for (auto& s : listenerSources) {
+        alSourcefv(s, AL_POSITION, pos);
+    }
+
+    for (int i = 0; i < 3; i++)
+        lastPosition[i] = pos[i];
+}
+
+void SoundAL::play(int source, bool atListener) {
+    if ((!init) || (!enabled))
+        return;
+
+    if (atListener) {
+        if ((source >= 0) && (source < listenerSources.size()))
+            alSourcePlay(listenerSources.at(source));
+        else
+            getLog() << "SoundAL: Can't play non-existing listener source!" << Log::endl;
+    } else {
+        if ((source >= 0) && (source < sources.size()))
+            alSourcePlay(sources.at(source));
+        else
+            getLog() << "SoundAL: Can't play non-existing source!" << Log::endl;
+    }
+}
+
+void SoundAL::stopAll() {
+    if (!init)
+        return;
+
+    alSourceStopv(sources.size(), &sources[0]);
+    alSourceStopv(listenerSources.size(), &listenerSources[0]);
+}
+
+void SoundAL::setEnabled(bool on) {
+    enabled = on;
+}
+
+bool SoundAL::getEnabled() {
+    return enabled;
+}
+
+void SoundAL::setVolume(float vol) {
+    volume = vol;
+
+    if (init)
+        alListenerf(AL_GAIN, volume);
+}
+
+float SoundAL::getVolume() {
+    return volume;
+}
+

src/Window.cpp → src/system/Window.cpp

 #include "global.h"
 #include "math/math.h"
 #include "utils/strings.h"
-#include "Window.h"
+#include "system/Window.h"
 
 int Window::initializeGL() {
     // Print driver support information

src/WindowGLUT.cpp → src/system/WindowGLUT.cpp

 #include "RunTime.h"
 #include "UI.h"
 #include "utils/strings.h"
-#include "WindowGLUT.h"
+#include "system/WindowGLUT.h"
 
 //! \todo Modifier keys currently don't create keyboard events...
 

src/WindowSDL.cpp → src/system/WindowSDL.cpp

 #include "RunTime.h"
 #include "UI.h"
 #include "utils/strings.h"
-#include "WindowSDL.h"
+#include "system/WindowSDL.h"
 
 #define SUBSYSTEMS_USED (SDL_INIT_VIDEO | SDL_INIT_EVENTS)