Sound Manager to master

CMakeLists.txt

@@ -14,6 +14,7 @@ include(${CMAKE_SOURCE_DIR}/cmake/ShaderBuild.cmake)
 find_package(Threads REQUIRED)
 find_package(Freetype REQUIRED)
 find_package(Vulkan REQUIRED)
+find_package(OpenAL)
 
 # Try: cmake . -B build && cmake --build build/
 if (CMAKE_BINARY_DIR STREQUAL CMAKE_SOURCE_DIR)
@@ -33,6 +34,19 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 	endif()
 endif()
 
+if (NOT OpenAL_FOUND)
+    message(STATUS "OpenAL was NOT found, falling back to OpenAL-Soft!")
+
+    FetchContent_Declare(
+            openal-soft
+            GIT_REPOSITORY https://github.com/kcat/openal-soft
+            GIT_TAG 1.23.1
+            GIT_PROGRESS TRUE
+    )
+
+    FetchContent_MakeAvailable(openal-soft)
+endif()
+
 # Don't fail on systems without X11 libraries
 if (UNIX)
 	find_program(WAYLAND_SCANNER_EXECUTABLE NAMES wayland-scanner)
@@ -103,12 +117,18 @@ compile_glsl_directory(
 		VULKAN_TARGET "vulkan1.2"
 )
 
+if(NOT DEFINED OpenAL_INCLUDE_DIRS)
+	set(OpenAL_INCLUDE_DIRS "${OpenAL_SOURCE_DIR}/include")
+	message(STATUS "Applying OpenAL include directory fix")
+endif()
+
 set(CHECKLIGHT_LIBRARIES
 		${glm_SOURCE_DIR}                        # Headers in ./glm
 		${glfw_SOURCE_DIR}/include               # Headers in ./GLFW
 		${stb_SOURCE_DIR}                        # Headers in ./
 		${Vulkan_INCLUDE_DIRS}                   # Headers in ./vulcan
 		${vma_SOURCE_DIR}/include                # Headers in ./
+		${OpenAL_INCLUDE_DIRS}                   # Headers in ./AL
 )
 
 add_library(checklight_common INTERFACE)
@@ -122,13 +142,16 @@ file(GLOB_RECURSE CHECKLIGHT_ENGINE_SOURCES "src/engine/*.cpp")
 add_library(checklight_engine_system ${CHECKLIGHT_ENGINE_SOURCES})
 
 file(GLOB_RECURSE CHECKLIGHT_RENDER_SOURCES "src/render/*.cpp")
-add_library(checklight_render_system ${CHECKLIGHT_RENDER_SOURCES})
+add_library(checklight_render_system ${CHECKLIGHT_RENDER_SOURCES} )
 
 file(GLOB_RECURSE CHECKLIGHT_SHARED_SOURCES "src/shared/*.cpp")
-add_library(checklight_shared_system ${CHECKLIGHT_SHARED_SOURCES})
+add_library(checklight_shared_system ${CHECKLIGHT_SHARED_SOURCES} )
 
 file(GLOB_RECURSE CHECKLIGHT_INPUT_SOURCES "src/input/*.cpp")
-add_library(checklight_input_system ${CHECKLIGHT_INPUT_SOURCES})
+add_library(checklight_input_system ${CHECKLIGHT_INPUT_SOURCES} )
+
+file(GLOB_RECURSE CHECKLIGHT_SOUND_SOURCES "src/sound/*.cpp")
+add_library(checklight_sound_system ${CHECKLIGHT_SOUND_SOURCES} )
 
 file(GLOB_RECURSE CHECKLIGHT_GUI_SOURCES "src/gui/*.cpp")
 add_library(checklight_gui_system ${CHECKLIGHT_GUI_SOURCES})
@@ -138,7 +161,7 @@ add_library(checklight_external
 		lib/stb_image_write.cpp
 		lib/stb_vorbis.cpp
 		lib/vk_mem_alloc.cpp
-)
+ )
 
 target_include_directories(checklight_external PRIVATE
 		${CHECKLIGHT_LIBRARIES}
@@ -174,6 +197,12 @@ target_link_libraries(checklight_input_system PRIVATE
 		checklight_common
 )
 
+target_link_libraries(checklight_sound_system PRIVATE
+		checklight_common
+		OpenAL::OpenAL
+		checklight_external
+)
+
 target_link_libraries(checklight_gui_system PRIVATE
 		checklight_common
 		checklight_input_system
@@ -186,6 +215,7 @@ target_link_libraries(checklight PRIVATE
 		checklight_render_system
 		checklight_shared_system
 		checklight_input_system
+		checklight_sound_system
 		checklight_gui_system
 		checklight_engine_system
 )
@@ -269,3 +299,11 @@ if(EXISTS "${CMAKE_SOURCE_DIR}/assets")
 	add_dependencies(checklight_common copy-assets)
 	add_dependencies(checklight_common compile-shaders)
 endif()
+
+# Needed on MSVS to fix missing DLL errors during runtime
+if (WIN32)
+	add_custom_command(TARGET checklight_sound_system POST_BUILD
+			COMMAND ${CMAKE_COMMAND} -E copy_if_different
+			"${openal-soft_BINARY_DIR}/OpenAL32.dll"
+			"${CMAKE_BINARY_DIR}/OpenAL32.dll")
+endif()

src/external.hpp

@@ -7,7 +7,6 @@
 #include <cstdint>
 
 // C++ libs
-#include <iostream>
 #include <vector>
 #include <functional>
 #include <list>
@@ -58,6 +57,12 @@
 #include <glm/gtx/hash.hpp>
 #include <glm/gtx/norm.hpp>
 
+
+// OpenAL
+#include <AL/al.h>
+#include <AL/alc.h>
+
+
 // Vulkan Format Database
 #include "vk_format_info.hpp"
 

src/main.cpp

@@ -1,4 +1,3 @@
-
 #include <gui/context.hpp>
 #include <gui/debug/render.hpp>
 #include <gui/theme/dark.hpp>
@@ -8,7 +7,7 @@
 #include <gui/widget/text.hpp>
 #include <shared/args.hpp>
 #include <shared/logger.hpp>
-
+#include "sound/sound.hpp"
 #include "render/render.hpp"
 #include "input/input.hpp"
 #include "engine/engine.hpp"
@@ -100,6 +99,11 @@ static void entry(Args& args) {
 		objects.push_back(object);
 	}
 
+	system.getParameters().setAmbientLight(glm::vec3(0.0, 0.0, 0.0));
+	system.getParameters().setDenoise(true);
+	system.getParameters().setShadows(true);
+	system.getParameters().setGISamples(1);
+
 	system.getLightManager().createDirectionalLight(
 		{0.0, 3.5, -1.0},
 		{1.0, 1.0, 1.0},
@@ -114,6 +118,19 @@ static void entry(Args& args) {
 		true
 	);
 
+	SoundListener::setPosition(0, 0, 0);
+	SoundManager& sm = SoundManager::getInstance();
+	auto sso = std::make_shared<SoundSourceObject>();
+	sm.addSource(sso);
+	sm.createSoundClipAndAddToSourceObject("assets/sounds/testOGG.ogg", sso);
+	sso->setPosition(0.0f, 4.8f, 0.0f);
+	sso->setMaxDistance(10.0f);
+	sso->setReferenceDistance(1.0f);
+	sso->setRolloffFactor(1.0f);
+	sso->setMinGain(0.0f);
+	sso->setMaxGain(1.0f);
+	SoundListener::setDistanceModel(AL_LINEAR_DISTANCE);
+	//window.getInputDispatcher().registerListener(std::make_shared<DebugInputListener>());
 	while (!window.shouldClose()) {
 		window.poll();
 
@@ -143,9 +160,12 @@ static void entry(Args& args) {
 		point_light->vector = glm::vec3(3.0, 2.0, 18.0 * sin(glfwGetTime() / 8));
 		point_light->color = glm::vec3(sin(glfwGetTime() / 2) * 0.5 + 0.5, sin(glfwGetTime() / 3 + 2) * 0.5 + 0.5, sin(glfwGetTime() / 5 + 4) * 0.5 + 0.5);
 		system.getLightManager().flush();
-
+		
 		// render the scene
 		system.draw();
+		sm.playSound(sso);
+		SoundListener::setPosition(current_board->getCamPos());
+		SoundListener::setOrientation(current_board->getCamForward(),glm::vec3(0.0f,1.0f,0.0f));
 	}
 
 	system.wait();

src/sound/clip.cpp

@@ -0,0 +1,172 @@
+#include "clip.hpp"
+
+#include "debug.hpp"
+#include "shared/logger.hpp"
+
+SoundClip::SoundClip(){
+	alGetError();
+	alGenBuffers(1, &buffer);
+	alCheckError("durring clip creation");
+}
+
+SoundClip::~SoundClip(){
+	alDeleteBuffers(1, &buffer);
+}
+
+void SoundClip::convertChannels(int* audio_size, int channels, short* data) {
+	/// Resize to 1 channel
+	int new_audio_size = *audio_size / channels;
+	/// Get data only from 1 channel
+	int j = 0;
+	int sum_audio = 0;
+	for (int i = 0; i < *audio_size; i++) {
+		sum_audio += data[i];
+		/// Check if we are at the end of the block of channels
+		/// If we are, get average of the channels and save to the output
+		/// All channels convert to mono as average of the channels
+		if (i % channels == (channels-1)) {
+			data[j] = sum_audio/channels;
+			sum_audio = 0;
+			j++;
+		}	
+	}
+	*audio_size = new_audio_size;
+}
+
+void SoundClip::loadOGGFile(const char* filename) {
+	// clean up errors
+	alGetError();
+
+	int channels, sample_rate;
+	short* output;
+
+	// get output, channels, sample rate from filename and size of the data
+	ALsizei size_block = stb_vorbis_decode_filename(filename, &channels, &sample_rate, &output);
+
+	if (size_block == -1) {
+		out::error("Failed to decode OGG file '%s'!", filename);
+		free(output);
+		return;
+	}
+	this->path = filename;
+
+	/// Check of the file has more than 2 channels. If it has, convert it to mono
+	if (channels >= 2) {
+		convertChannels(&size_block, channels, output);
+	}
+
+	ALenum format = AL_FORMAT_MONO16;
+	ALsizei audio_size = size_block * sizeof(short);
+
+	// Create buffer
+	alBufferData(buffer, format, output, audio_size, sample_rate);
+	free(output);
+
+	if (alGetError() != AL_NO_ERROR) {
+		FAULT("Failed to upload the sound buffer!");
+	}
+
+	out::debug("Loaded sound '%s'", filename);
+}
+
+void SoundClip::loadWAVFile(const char* filename) {
+	alGetError();
+	/// WAV File Header
+	/// https://docs.fileformat.com/audio/wav/
+	/// http://soundfile.sapp.org/doc/WaveFormat/
+	struct WAVFile {
+		char chunk_ID[4];
+		uint32_t chunk_size;
+		char format[4];
+
+		char subchunk1_ID[4];
+		uint32_t subchunk1_size;
+		uint16_t audio_format;
+		uint16_t num_channels;
+		uint32_t sample_rate;
+		uint32_t byte_rate;
+		uint16_t block_align;
+		uint16_t bits_per_sample;
+
+		char subchunk2_ID[4];
+		uint32_t subchunk2_size;
+	};
+
+	std::ifstream wav_file(filename, std::ios::binary);
+	WAVFile wav_header;
+	/// Read header from file
+	if (!wav_file.read(reinterpret_cast<char*>(&wav_header), sizeof(WAVFile))) {
+		out::error("Failed decode WAV file '%s', can't read file header!", filename);
+		return;
+	}
+
+	ALsizei frequency = wav_header.sample_rate;
+	/// Read all audio data without header from file
+	std::vector<short> data;
+	data.resize(wav_header.subchunk2_size);
+
+	if (!wav_file.read(reinterpret_cast<char*>(data.data()), wav_header.subchunk2_size)) {
+		out::error("Failed decode WAV file '%s', can't read file chunk!", filename);
+		return;
+	}
+	ALsizei audio_size = wav_header.subchunk2_size;
+
+	/// Check of the file has more than 2 channels. If it has, convert it to mono
+	if (wav_header.num_channels >= 2) {
+		convertChannels(&audio_size, wav_header.num_channels, data.data());
+	}
+
+	ALenum format;
+	if (wav_header.bits_per_sample == 8) {
+		format = AL_FORMAT_MONO8;
+	}
+	else if (wav_header.bits_per_sample == 16) {
+		format = AL_FORMAT_MONO16;
+	} else {
+		out::error("Failed decode WAV file '%s', unsupported channel count, expected mono or stereo!", filename);
+		return;
+	}
+
+	alBufferData(buffer, format, data.data(), audio_size, frequency);
+
+	if (alGetError() != AL_NO_ERROR) {
+		FAULT("Failed to upload the sound buffer!");
+	}
+
+	out::debug("Loaded sound '%s'", filename);
+}
+
+void SoundClip::loadAudio(const char* filename) {
+	std::ifstream input_file {filename, std::ios::binary};
+
+	if (!input_file) {
+		out::error("Can't open sound file '%s'!", filename);
+		return;
+	}
+
+	char header[4];
+	input_file.read(header, 4);
+	input_file.close();
+
+	if (std::string(header, 4) == "OggS") {
+		loadOGGFile(filename);
+		return;
+	}
+
+	if (std::string(header, 4) == "RIFF" || std::string(header, 4) == "WAVE") {
+		loadWAVFile(filename);
+		return;
+	}
+
+	out::error("Can't open sound file '%s', unsupported or invalid format!", filename);
+
+}
+
+ALuint SoundClip::getBuffer() {
+	return buffer;
+}
+
+std::string SoundClip::getPath()
+{
+	return path;
+}