Added Sound initialization

include/OpenRaider.h

 
 #include <vector>
 
+#include "Sound.h"
 #include "Window.h"
 
 /*!
     bool mInit;
     bool mRunning;
     Window *mWindow;
+
+    Sound *mSound;
 };
 
 #endif

include/Sound.h

      * \brief Initialize sound system
      * \returns 0 on success or < 0 error flags
      */
-    int init();
+    int initialize();
+
+    void setEnabled(bool on);
+
+    /*!
+     * \brief Set the volume
+     * \param vol new source gain
+     */
+    void setVolume(float vol);
 
     /*!
      * \brief Get number of registered sources
     void clear();
 
     /*!
-     * \brief Set the volume
-     * \param vol new source gain
-     */
-    void setVolume(float vol);
-
-    /*!
      * \brief Move listener and repositions them
      * \param pos New position for listener
      * \param angle New orientation for listener
 
 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

src/OpenRaider.cpp

     mInit = false;
     mRunning = false;
 
+    mSound = new Sound();
     mWindow = new WindowSDL();
 }
 
 OpenRaider::~OpenRaider() {
+    if (mSound)
+        delete mSound;
+
     if (mWindow)
         delete mWindow;
 }
             printf("set-audio-Error: Invalid value (%s)\n", value);
             return -4;
         }
-        // TODO enable audio
+        mSound->setEnabled(audio);
     } else if (strcmp(var, "volume") == 0) {
-        // TODO set volume
+        float vol = 1.0f;
+        if (sscanf(value, "%f", &vol) != 1) {
+            printf("set-volume-Error: Invalid value (%s)\n", value);
+        }
+        mSound->setVolume(vol);
     } else if (strcmp(var, "mouse_x") == 0) {
         // TODO set
     } else if (strcmp(var, "mouse_y") == 0) {
     if (mWindow->initializeFont() != 0)
         return -3;
 
+    // Initialize sound
+    if (mSound->initialize() != 0)
+        return -4;
+
     mInit = true;
 
     return 0;

src/Sound.cpp

 #include <OpenAL/al.h>
 #else
 #include <AL/al.h>
+#include <fcntl.h>
+#include <unistd.h>
 #endif
 
 #include <AL/alut.h>
 
-#include <time.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
+#include <cstdio>
+#include <cstdlib>
 #include <assert.h>
 
 #include "math/math.h"
 #include "Sound.h"
 
 Sound::Sound() {
+    mEnabled = false;
     mInit = false;
     mVolume = 1.0f;
 }
         alutExit();
 }
 
-int Sound::init() {
+int Sound::initialize() {
     assert(mInit == false);
 
-#ifndef __APPLE__
-    int fd;
-
-    fd = open("/dev/dsp", O_RDWR);
+    if (!mEnabled)
+        return 0;
 
+#ifndef __APPLE__
+    int fd = open("/dev/dsp", O_RDWR);
     if (fd < 0) {
-        perror("Sound::Init> Could not open /dev/dsp : ");
+        printf("Could not initialize Sound (/dev/dsp)\n");
         return -1;
     }
-
     close(fd);
 #endif
 
     alcMakeContextCurrent(Context);
 
     if (alutInitWithoutContext(NULL, NULL) == AL_FALSE) {
-        printf("Sound::Init> Could not initialize alut (%s)\n", alutGetErrorString(alutGetError()));
+        printf("ALUT-Error: %s\n", alutGetErrorString(alutGetError()));
         return -2;
     }
 
     mInit = true;
-    printf("Created OpenAL Context\n");
 
     return 0;
 }
 
+void Sound::setEnabled(bool on) {
+    mEnabled = on;
+}
+
+void Sound::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;
+}
+
 int Sound::registeredSources() {
-    assert(mInit == true);
     assert(mSource.size() == mBuffer.size());
 
+    if ((!mEnabled) || (!mInit))
+        return 0;
+
     return mSource.size();
 }
 
 void Sound::clear() {
-    assert(mInit == true);
     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]);
     mBuffer.clear();
 }
 
-void Sound::setVolume(float vol) {
-    assert(mInit == true);
-    assert(mSource.size() == mBuffer.size());
-
-    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;
-}
-
 void Sound::listenAt(float pos[3], float angle[3]) {
-    assert(mInit == true);
     assert(mSource.size() == mBuffer.size());
     assert(pos != NULL);
     assert(angle != NULL);
 
+    if ((!mEnabled) || (!mInit))
+        return;
+
     alListenerfv(AL_POSITION, pos);
     alListenerfv(AL_ORIENTATION, angle);
 }
 
 void Sound::sourceAt(int source, float pos[3]) {
-    assert(mInit == true);
     assert(mSource.size() == mBuffer.size());
     assert(source >= 0);
     assert(source < (int)mSource.size());
     assert(pos != NULL);
 
+    if ((!mEnabled) || (!mInit))
+        return;
+
     alSourcefv(mSource[source], AL_POSITION, pos);
 }
 
     ALvoid *data;
     int id;
 
-    assert(mInit == true);
     assert(mSource.size() == mBuffer.size());
     assert(filename != NULL);
     assert(filename[0] != '\0');
     assert(source != NULL);
 
+    if ((!mEnabled) || (!mInit)) {
+        *source = 0;
+        return 0;
+    }
+
     *source = -1;
     id = mSource.size();
 
     alGetError();
     alGenBuffers(1, &mBuffer[id]);
     if (alGetError() != AL_NO_ERROR) {
-        fprintf(stderr, "Sound::AddFile> alGenBuffers call failed\n");
+        printf("Could not load wav file (alGenBuffers)\n");
         return -1;
     }
 
     alGetError();
     alGenSources(1, &mSource[id]);
     if (alGetError() != AL_NO_ERROR) {
-        fprintf(stderr, "Sound::AddFile> alGenSources call failed\n");
+        printf("Could not load wav file (alGenSources)\n");
         return -2;
     }
 
-    // err = alutLoadWAV(filename, &data, &format, &size, &bits, &freq);
-    // is deprecated!
     data = alutLoadMemoryFromFile(filename, &format, &size, &freq);
     if (alutGetError() != ALUT_ERROR_NO_ERROR) {
-        fprintf(stderr, "Could not load %s\n", filename);
+        printf("Could not load %s\n", filename);
         return -3;
     }
 
     int error = 0;
     int id;
 
-    assert(mInit == true);
     assert(mSource.size() == mBuffer.size());
     assert(wav != NULL);
     assert(source != NULL);
 
+    if ((!mEnabled) || (!mInit)) {
+        *source = 0;
+        return 0;
+    }
+
     *source = -1;
     id = mSource.size();
 
     alGetError();
     alGenBuffers(1, &mBuffer[id]);
     if (alGetError() != AL_NO_ERROR) {
-        fprintf(stderr, "Sound::AddWave> alGenBuffers call failed\n");
+        printf("Could not load wav (alGenBuffers)\n");
         return -1;
     }
 
     alGetError();
     alGenSources(1, &mSource[id]);
     if (alGetError() != AL_NO_ERROR) {
-        fprintf(stderr, "Sound::AddWave> alGenSources call failed\n");
+        printf("Could not load wav (alGenSources)\n");
         return -2;
     }
 
-    //AL_FORMAT_WAVE_EXT does not exist on Mac!"
-    // alBufferData(mBuffer[id], AL_FORMAT_WAVE_EXT, data, size, freq);
-    // Idea: Fill Buffer with
-    // alutLoadMemoryFromFileImage
-    //     (const ALvoid *data, ALsizei length, ALenum *format, ALsizei *size, ALfloat *frequency)
-
     data = alutLoadMemoryFromFileImage(wav, length, &format, &size, &freq);
     if (((error = alutGetError()) != ALUT_ERROR_NO_ERROR) || (data == NULL)) {
-        fprintf(stderr, "Could not load wav buffer (%s)\n", alutGetErrorString(error));
+        printf("Could not load wav buffer (%s)\n", alutGetErrorString(error));
         return -3;
     }
 
 }
 
 void Sound::play(int source) {
-    assert(mInit == true);
     assert(mSource.size() == mBuffer.size());
     assert(source >= 0);
     assert(source < (int)mSource.size());
 
+    if ((!mEnabled) || (!mInit))
+        return;
+
     alSourcePlay(mSource[source]);
 }
 
 void Sound::stop(int source) {
-    assert(mInit == true);
     assert(mSource.size() == mBuffer.size());
     assert(source >= 0);
     assert(source < (int)mSource.size());
 
+    if ((!mEnabled) || (!mInit))
+        return;
+
     alSourceStop(mSource[source]);
 }