Sound Manager to master

CMakeLists.txt

@@ -15,6 +15,7 @@ find_package(Python REQUIRED COMPONENTS Interpreter)
 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)
@@ -34,6 +35,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)
@@ -104,12 +118,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)
@@ -123,20 +143,23 @@ 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} )
 
 add_library(checklight_external
 		lib/stb_image.cpp
 		lib/stb_image_write.cpp
 		lib/stb_vorbis.cpp
 		lib/vk_mem_alloc.cpp
-)
+ )
 
 target_include_directories(checklight_external PRIVATE
 		${CHECKLIGHT_LIBRARIES}
@@ -170,11 +193,18 @@ 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 PRIVATE
 		checklight_common
 		checklight_render_system
 		checklight_shared_system
 		checklight_input_system
+		checklight_sound_system
 		checklight_engine_system
 )
 

src/external.hpp

@@ -54,6 +54,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,7 +1,7 @@
-
 #include "render/render.hpp"
 #include "input/input.hpp"
 #include "engine/engine.hpp"
+#include "sound/sound.hpp"
 
 static void drawUserInterface(ImmediateRenderer& immediate, float width, float height) {
 	immediate.setSprite("assets/image/corners.png");
@@ -117,6 +117,18 @@ int main() {
 		.shadow = true
 	});
 
+	SoundListener::setPosition(0, 0, 0);
+	SoundManager& sm = SoundManager::getInstance();
+	auto sso = std::make_shared<SoundSourceObject>();
+	sm.addSource(sso);
+	sm.createSoundClipAndAddToSourceObject("assets/sounds/testWAV.wav", sso);
+	sso->setPosition(0, 0, 0);
+	sso->setMaxDistance(20);
+	sso->setReferenceDistance(1.0f);
+	sso->setRolloffFactor(1.0f);
+	sso->setMinGain(0.0f);
+	SoundListener::setDistanceModel(AL_INVERSE_DISTANCE);
+
 	while (!window.shouldClose()) {
 		window.poll();
 
@@ -135,9 +147,11 @@ int main() {
 		point_light->position = 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().x, current_board->getCamPos().y, current_board->getCamPos().z);
 	}
 
 	system.wait();

src/sound/clip.cpp

@@ -0,0 +1,159 @@
+#include "clip.hpp"
+
+SoundClip::SoundClip(){
+	alGetError();
+	alGenBuffers(1, &buffer);
+
+	ALenum error;
+	if ((error = alGetError()) != AL_NO_ERROR){
+		std::cerr << ("Clip -> SCinit: Failed to generate buffers\n");  //throw exception
+		return;
+	}
+}
+
+SoundClip::~SoundClip(){
+	alDeleteBuffers(1, &buffer);
+}
+
+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) {
+		std::cerr << ("SoundClip -> OGG file load error\n");
+		return;
+	}
+	this->path = filename;
+
+	/// Check of the file has more than 2 channels. If it has, convert it to mono
+	if (channels >= 2) {
+		/// Resize to 1 channel
+		size_block /= channels;
+		short* output2 = new short[size_block];
+		/// Get data only from 1 channel
+		for (int i = 0;i < size_block;i++) {
+			output2[i] = output[i * channels];
+		}
+		delete[] output;
+		output = output2;
+	}
+
+	ALenum format = AL_FORMAT_MONO16;
+	ALsizei audio_size = size_block * sizeof(short);
+	// Create buffer
+	alBufferData(buffer, format, output, audio_size, sample_rate);
+	delete[] output;
+	ALenum error;
+	if ((error = alGetError()) != AL_NO_ERROR) {
+		std::cerr << ("Clip -> loadOGGFile: Failed to load file to buffer\n");  //throw exception
+		return;
+	}
+
+	printf("SoundClip -> OGG file loaded\n");
+}
+
+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
+	wav_file.read(reinterpret_cast<char*>(&wav_header), sizeof(WAVFile));
+
+	ALsizei frequency = wav_header.sample_rate;
+	/// Read all audio data without header from file
+	short* data = new short[wav_header.subchunk2_size];
+	wav_file.read(reinterpret_cast<char*>(data), wav_header.subchunk2_size);
+	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) {
+		/// Resize to 1 channel
+		audio_size /= wav_header.num_channels;
+		/// Get data only from 1 channel
+		short* output = new short[audio_size];
+		for (int i = 0; i < audio_size; i++) {
+			output[i] = data[i * wav_header.num_channels];
+		}
+		delete[] data;
+		data = output;
+	}
+
+	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 {
+		std::cerr << ("SoundClip -> WAV file load error\n");
+		delete[] data;
+		return;
+	}
+
+	alBufferData(buffer, format, data, audio_size, frequency);
+	delete[] data;
+
+	ALenum error;
+	if ((error = alGetError()) != AL_NO_ERROR) {
+		std::cerr << ("Clip -> loadWAVFile: Failed to load file to buffer\n");  //throw exception
+		return;
+	}
+
+	printf("SoundClip -> WAV file loaded\n");
+}
+
+void SoundClip::loadAudio(const char* filename){
+	std::ifstream input_file(filename, std::ios::binary);
+	if (!input_file) {
+		std::cerr << ("SoundClip -> addAudio: File not found\n");
+		return;
+	}
+	char header[4];
+	input_file.read(header, 4);
+	input_file.close();
+
+	if (std::string(header, 4) == "OggS") {
+		loadOGGFile(filename);
+	}	
+	else if (std::string(header, 4) == "RIFF" || std::string(header, 4) == "WAVE") 
+		loadWAVFile(filename);
+	else
+		std::cerr << ("SoundClip -> addAudio: File not supported\n");
+}
+
+ALuint SoundClip::getBuffer() {
+	return buffer;
+}
+
+std::string SoundClip::getPath()
+{
+	return path;
+}

src/sound/clip.hpp

@@ -0,0 +1,42 @@
+#pragma once
+#include "external.hpp"
+
+//@TODO poprawic wczytywanie plikow audio stereo, kilka bufferow dla jednego pliku, rozdzielic kanaly na mono 
+
+/// Object to management of buffers
+/// In this version provide management only on one buffer
+class SoundClip {
+private:
+
+	/// Pointer to id of buffers
+	ALuint buffer;
+	/// Path of buffer in buffer
+	std::string path;
+
+protected:
+
+	/// Load ogg file to buffer
+	void loadOGGFile(const char* filename);
+	/// Load wav file to buffer
+	void loadWAVFile(const char* filename);
+
+public:
+
+	SoundClip();
+	~SoundClip();
+
+	/// Method to create audio buffer for audio file
+	/// If the audio file has more than 1 channel, converts to mono
+	/// by extracting only one channel (first channel)
+	/// If you want to use other method to convert, overwrite loadOGGFile or loadWAVFile
+	/// Enable only OGG and WAV files
+	/// 
+	/// @param path Path to the audio file
+	void loadAudio(const char* path);
+
+	/// Get the buffer
+	ALuint getBuffer();
+
+	/// Get Path from the buffer
+	std::string getPath();
+};