WAV sounds are finally playing, YAY!

Author: NicusorN5

3DRadSpace/3DRadSpace_CPPSample/MyGame.cpp

@@ -43,7 +43,7 @@ void MyGame::Load()
 {
 	Game::Load();
 
-	_sound = this->Content->Load<Sound>("Data\\Sounds\\explosion.ogg");
+	_sound = this->Content->Load<Sound>("Data\\Sounds\\myfile.wav");
 	_soundInstance = std::make_unique<SoundInstance>(_sound);
 	_soundInstance->SetLooping(false);
 

3DRadSpace/CMakeSettings.json

@@ -1,39 +1 @@
-{
-  "configurations": [
-    {
-      "name": "x64-Debug",
-      "generator": "Ninja",
-      "configurationType": "Debug",
-      "inheritEnvironments": [ "msvc_x64_x64" ],
-      "buildRoot": "${projectDir}\\out\\build\\${name}",
-      "installRoot": "${projectDir}\\out\\install\\${name}",
-      "cmakeCommandArgs": "",
-      "ctestCommandArgs": "",
-      "variables": [
-        {
-          "name": "CMAKE_BUILD_TYPE",
-          "value": "Debug",
-          "type": "STRING"
-        }
-      ]
-    },
-    {
-      "name": "x64-Release",
-      "generator": "Ninja",
-      "configurationType": "RelWithDebInfo",
-      "buildRoot": "${projectDir}\\out\\build\\${name}",
-      "installRoot": "${projectDir}\\out\\install\\${name}",
-      "cmakeCommandArgs": "",
-      "buildCommandArgs": "",
-      "ctestCommandArgs": "",
-      "inheritEnvironments": [ "msvc_x64_x64" ],
-      "variables": [
-        {
-          "name": "CMAKE_BUILD_TYPE",
-          "value": "RelWithDebInfo",
-          "type": "STRING"
-        }
-      ]
-    }
-  ]
-}
+

3DRadSpace/Engine3DRadSpace/Audio/AudioBuffer.cpp

@@ -1,5 +1,4 @@
 #include "AudioBuffer.hpp"
-#include "AudioBuffer.hpp"
 #include <al.h>
 #include <vorbis\codec.h>
 #include <vorbis\vorbisenc.h>
@@ -17,7 +16,7 @@ AudioBuffer::AudioBuffer(char* buffer, int channel, int sampleRate, int bps, int
 {
 }
 
-std::optional<AudioBuffer> AudioBuffer::FromWAV(const std::filesystem::path& path)
+std::expected<AudioBuffer, AudioBuffer::WAVLoadError> AudioBuffer::FromWAV(const std::filesystem::path& path)
 {
 	//https://stackoverflow.com/questions/36949957/loading-a-wav-file-for-openal
     auto convertToInt = [](char* buffer, int len) -> int
@@ -38,45 +37,51 @@ std::optional<AudioBuffer> AudioBuffer::FromWAV(const std::filesystem::path& pat
     int size;
     char buffer[4];
 
-    std::ifstream in(path);
+    std::ifstream in(path, std::ios::binary);
+
+    if (in.bad() || in.fail())
+    {
+        return std::unexpected(AudioBuffer::WAVLoadError::CannotOpen);
+    }
+
     in.read(buffer, 4);
 
     if(strncmp(buffer, "RIFF", 4) != 0)
     {
-        //"Error here, not a valid WAV file, RIFF not found in header\n This was found instead: "
-        return std::nullopt;
+        //RIFF not found in header
+        return std::unexpected(AudioBuffer::WAVLoadError::RIFFNotFound);
     }
 
     in.read(buffer, 4);//size of file. Not used. Read it to skip over it.  
     in.read(buffer, 4);//Format, should be WAVE
     if(strncmp(buffer, "WAVE", 4) != 0)
     {
         //not a valid WAV file, RIFF not found in header
-        return std::nullopt;
+        return std::unexpected(AudioBuffer::WAVLoadError::RIFFNotFound);
     }
 
     in.read(buffer, 4);//Format Space Marker. should equal fmt (space)
 
     if(strncmp(buffer, "fmt ", 4) != 0)
     {
         //not a valid WAV file, Format Marker not found in header
-        return std::nullopt;
+        return std::unexpected(AudioBuffer::WAVLoadError::NoFormatMarker);
     }
 
     in.read(buffer, 4);//Length of format data. Should be 16 for PCM, meaning uncompressed.
 
     if(convertToInt(buffer, 4) != 16)
     {
         // not a valid WAV file, format length wrong in header
-        return std::nullopt;
+        return std::unexpected(AudioBuffer::WAVLoadError::WrongFormatLength);
     }
 
     in.read(buffer, 2);//Type of format, 1 = PCM
 
     if(convertToInt(buffer, 2) != 1)
     {
         // not a valid WAV file, file not in PCM format
-        return std::nullopt;
+        return std::unexpected(AudioBuffer::WAVLoadError::NotPCM);
     }
 
     in.read(buffer, 2);//Get number of channels. 
@@ -97,7 +102,7 @@ std::optional<AudioBuffer> AudioBuffer::FromWAV(const std::filesystem::path& pat
     bps = convertToInt(buffer, 2);
 
     //Skip character data, which marks the start of the data that we care about. 
-    in.read(buffer, 4);//"data" chunk. 
+    in.read(buffer, 4); //"data" chunk. 
 
     in.read(buffer, 4); //Get size of the data
 
@@ -106,10 +111,14 @@ std::optional<AudioBuffer> AudioBuffer::FromWAV(const std::filesystem::path& pat
     if(size < 0)
     {
         //not a valid WAV file, size of file reports 0
-        return std::nullopt;
+        return std::unexpected(AudioBuffer::WAVLoadError::NullSize);
     }
 
     char* data = new char[size];
+    if (data == nullptr)
+    {
+        return std::unexpected(AudioBuffer::WAVLoadError::OutOfMemory);
+    }
 
     in.read(data, size);//Read audio data into buffer, return.
 
@@ -118,29 +127,17 @@ std::optional<AudioBuffer> AudioBuffer::FromWAV(const std::filesystem::path& pat
     int format;
     if (channels == 1)
     {
-        if (bps == 8)
-        {
-            format = AL_FORMAT_MONO8;
-        }
-        else {
-            format = AL_FORMAT_MONO16;
-        }
+        format = bps == 8 ? AL_FORMAT_MONO8 : AL_FORMAT_MONO16;
     }
     else 
     {
-        if (bps == 8)
-        {
-            format = AL_FORMAT_STEREO8;
-        }
-        else {
-            format = AL_FORMAT_STEREO16;
-        }
+        format = bps == 8 ? AL_FORMAT_STEREO8 : AL_FORMAT_STEREO16;
     }
 
     return AudioBuffer(data, channels, sampleRate, bps, format, size);
 }
 
-std::optional<AudioBuffer> AudioBuffer::FromOGG(const std::filesystem::path& path)
+std::expected<AudioBuffer, AudioBuffer::OGGLoadError> AudioBuffer::FromOGG(const std::filesystem::path& path)
 {
     //https://gist.github.com/tilkinsc/f91d2a74cff62cc3760a7c9291290b29
 
@@ -150,21 +147,21 @@ std::optional<AudioBuffer> AudioBuffer::FromOGG(const std::filesystem::path& pat
     if(file == nullptr)
     {
         //Failed to open OGG file.
-        return std::nullopt;
+        return std::unexpected(AudioBuffer::OGGLoadError::CannotOpen);
 	}
 
     if(ov_open_callbacks(file, &vf, nullptr, 0, OV_CALLBACKS_NOCLOSE) < 0)
     {
         //Not a valid OGG file.
-        return std::nullopt;
+        return std::unexpected(AudioBuffer::OGGLoadError::Invalid);
     }
 
     vorbis_info* info = ov_info(&vf, -1);
     if(info == nullptr)
     {
         //Failed to get OGG info
         ov_clear(&vf);
-        return std::nullopt;
+        return std::unexpected(AudioBuffer::OGGLoadError::InfoFail);
     }
     int channels = info->channels;
     int sampleRate = info->rate;
@@ -177,7 +174,7 @@ std::optional<AudioBuffer> AudioBuffer::FromOGG(const std::filesystem::path& pat
     {
         //Failed to allocate memory for OGG buffer
         ov_clear(&vf);
-        return std::nullopt;
+        return std::unexpected(AudioBuffer::OGGLoadError::OutOfMemory);
 	}
 
     for(size_t bytesRead = 0, offset = 0, sel=0; ; offset += bytesRead)
@@ -198,7 +195,7 @@ std::optional<AudioBuffer> AudioBuffer::FromOGG(const std::filesystem::path& pat
             //Faulty OGG file.
             delete[] buffer;
             ov_clear(&vf);
-            return std::nullopt;
+            return std::unexpected(AudioBuffer::OGGLoadError::Invalid);
         }
 	}
     ov_clear(&vf);

3DRadSpace/Engine3DRadSpace/Audio/AudioBuffer.hpp

@@ -23,8 +23,30 @@ namespace Engine3DRadSpace::Audio
 		AudioBuffer& operator=(const AudioBuffer&) = delete;
 		AudioBuffer& operator=(AudioBuffer&&) = default;
 
-		static std::optional<AudioBuffer> FromWAV(const std::filesystem::path& path);
-		static std::optional<AudioBuffer> FromOGG(const std::filesystem::path& path);
+		enum class WAVLoadError
+		{
+			None,
+			CannotOpen,
+			RIFFNotFound,
+			NoFormatMarker,
+			WrongFormatLength,
+			NotPCM,
+			NullSize,
+			OutOfMemory
+		};
+
+		static std::expected<AudioBuffer, WAVLoadError> FromWAV(const std::filesystem::path& path);
+		
+		enum class OGGLoadError
+		{
+			None,
+			CannotOpen,
+			Invalid,
+			InfoFail,
+			OutOfMemory,
+		};
+		
+		static std::expected<AudioBuffer, OGGLoadError> FromOGG(const std::filesystem::path& path);
 
 		~AudioBuffer() = default;
 

3DRadSpace/Engine3DRadSpace/Audio/AudioEngine.cpp

@@ -13,13 +13,11 @@ void AudioEngine::_initializeContext()
 	_audioContext = alcCreateContext(static_cast<ALCdevice*>(_audioDevice), nullptr);
 	if(!_audioContext)
 	{
-		throw Exception("Failed to create audio scene!");
+		throw Exception("Failed to create audio context!");
 	}
 
 	alcMakeContextCurrent(static_cast<ALCcontext*>(_audioContext));
 
-	_hasEAX2support = static_cast<bool>(alIsExtensionPresent("EAX2.0"));
-
 	alGetError(); //clear error flag
 }
 
@@ -67,14 +65,17 @@ std::vector<std::string> AudioEngine::ListAudioDevices()
 	return deviceList;
 }
 
-void AudioEngine::SetListener(const Math::Vector3& vector)
+void AudioEngine::SwitchAudioDevice(const std::string& deviceName)
 {
-	alListener3f(0, vector.X, vector.Y, vector.Z);
-}
+	this->~AudioEngine();
 
-bool AudioEngine::HasEAX2Support() const noexcept
-{
-	return _hasEAX2support;
+	_audioDevice = alcOpenDevice(deviceName.c_str());
+	if (!_audioDevice)
+	{
+		throw Exception("Audio device initialization failed! " + deviceName + " was specified.");
+	}
+
+	_initializeContext();
 }
 
 AudioEngine::~AudioEngine()
@@ -87,9 +88,39 @@ AudioEngine::~AudioEngine()
 	alcCloseDevice(device);
 }
 
-void AudioEngine::Update()
+void AudioEngine::Update() const noexcept
 {
-	//alcProcessContext(static_cast<ALCcontext*>(_audioContext));
+	if(this->Listener.Enabled)
+	{
+
+		alListenerf(AL_GAIN, this->Listener.Volume);
+
+		alListener3f(
+			AL_POSITION,
+			this->Listener.Position.X,
+			this->Listener.Position.Y,
+			this->Listener.Position.Z
+		);
+
+		alListener3f(
+			AL_VELOCITY,
+			this->Listener.Velocity.X,
+			this->Listener.Velocity.Y,
+			this->Listener.Velocity.Z
+		);
+
+		float orientation[6] =
+		{
+			this->Listener.Direction.X,
+			this->Listener.Direction.Y,
+			this->Listener.Direction.Z,
+			this->Listener.Normal.X,
+			this->Listener.Normal.Y,
+			this->Listener.Normal.Z,
+		};
+
+		alListenerfv(AL_ORIENTATION, orientation);
+	}
 }
 
 std::optional<AudioError> AudioEngine::CheckErrors()

3DRadSpace/Engine3DRadSpace/Audio/AudioEngine.hpp

@@ -1,7 +1,7 @@
 #pragma once
 #include "AudioError.hpp"
 #include "../Core/Libs.hpp"
-#include "../Math/Vector3.hpp"
+#include "Listener.hpp"
 
 namespace Engine3DRadSpace::Audio
 {
@@ -29,16 +29,17 @@ namespace Engine3DRadSpace::Audio
 		AudioEngine& operator=(const AudioEngine&) = delete;
 		AudioEngine& operator=(AudioEngine&&) = delete;
 
+		class Listener Listener;
+
 		static std::vector<std::string> ListAudioDevices();
 
-		void SetListener(const Math::Vector3& vector);
+		void SwitchAudioDevice(const std::string& deviceName);
 
 		bool HasEAX2Support() const noexcept;
 
 		~AudioEngine();
 
-		// Inherited via IUpdateable
-		void Update();
+		void Update() const noexcept;
 
 		std::optional<AudioError> CheckErrors();
 	};

3DRadSpace/Engine3DRadSpace/Audio/Listener.hpp

@@ -0,0 +1,17 @@
+#pragma once
+#include "../Math/Vector3.hpp"
+
+namespace Engine3DRadSpace::Audio
+{
+	struct Listener
+	{
+		float Volume = 1.0f;
+		Math::Vector3 Position = Math::Vector3::Zero();
+		Math::Vector3 Velocity = Math::Vector3::Zero();
+
+		Math::Vector3 Direction = Math::Vector3::UnitZ();
+		Math::Vector3 Normal = Math::Vector3::UnitY();
+	
+		bool Enabled = true;
+	};
+}

3DRadSpace/Engine3DRadSpace/Audio/Sound.cpp

@@ -31,7 +31,7 @@ Sound::Sound(AudioEngine *audio, const std::filesystem::path& path) :
 	_sound(std::move(_attemptLoading(path)))
 {
 	//Generate OpenAL sound buffer
-    alGenBuffers(1, &_bufferID); //Create one buffer
+	alGenBuffers(1, &_bufferID); //Create one buffer
 	alBufferData(_bufferID, _sound._format, _sound._buffer.get(), _sound._size, _sound._sampleRate); //Set buffer.
 	if(audio->CheckErrors().has_value()) throw Exception("Failed to copy OpenAL buffer!");
 }