From 07adbf48e0781cd8c95983c1871a84b6160ee5bf Mon Sep 17 00:00:00 2001
From: Loek Le Blansch <loek@pipeframe.xyz>
Date: Thu, 14 Nov 2024 13:57:13 +0100
Subject: implement asset + more WIP audio system

---
 src/crepe/api/Config.h | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

(limited to 'src/crepe/api/Config.h')

diff --git a/src/crepe/api/Config.h b/src/crepe/api/Config.h
index e3f86bf..c3f9474 100644
--- a/src/crepe/api/Config.h
+++ b/src/crepe/api/Config.h
@@ -58,6 +58,20 @@ public:
 		 */
 		double gravity = 1;
 	} physics;
+
+	//! Asset loading options
+	struct {
+		/**
+		 * \brief Pattern to match for Asset base directory
+		 *
+		 * All non-absolute paths resolved using \c Asset will be made relative to
+		 * the first parent directory relative to the calling executable where
+		 * appending this pattern results in a path that exists. If this string is
+		 * empty, path resolution is disabled, and Asset will return all paths
+		 * as-is.
+		 */
+		std::string root_pattern = ".crepe-root";
+	} asset;
 };
 
 } // namespace crepe
-- 
cgit v1.2.3


From a685e5f743786cc6499e7ce8973bb78a83d101f7 Mon Sep 17 00:00:00 2001
From: Loek Le Blansch <loek@pipeframe.xyz>
Date: Tue, 26 Nov 2024 20:03:41 +0100
Subject: big WIP

---
 src/crepe/CMakeLists.txt          |   2 +
 src/crepe/ResourceManager.cpp     |  36 ++++++++++++
 src/crepe/ResourceManager.h       |  76 +++++++++++++++++++++++++
 src/crepe/api/AudioSource.h       |   1 +
 src/crepe/api/CMakeLists.txt      |   2 -
 src/crepe/api/Config.h            |  27 +--------
 src/crepe/api/ResourceManager.cpp |  41 --------------
 src/crepe/api/ResourceManager.h   |  69 -----------------------
 src/crepe/system/AudioSystem.cpp  |   2 +-
 src/crepe/system/AudioSystem.h    |   4 +-
 src/crepe/util/Log.cpp            |   2 +-
 src/crepe/util/Log.h              |  16 ++++++
 src/test/EventTest.cpp            |   1 -
 src/test/ResourceManagerTest.cpp  | 115 +++++++++++++++++++++++++++-----------
 src/test/main.cpp                 |  12 ++--
 15 files changed, 224 insertions(+), 182 deletions(-)
 create mode 100644 src/crepe/ResourceManager.cpp
 create mode 100644 src/crepe/ResourceManager.h
 delete mode 100644 src/crepe/api/ResourceManager.cpp
 delete mode 100644 src/crepe/api/ResourceManager.h

(limited to 'src/crepe/api/Config.h')

diff --git a/src/crepe/CMakeLists.txt b/src/crepe/CMakeLists.txt
index df15b8f..0313dfa 100644
--- a/src/crepe/CMakeLists.txt
+++ b/src/crepe/CMakeLists.txt
@@ -3,6 +3,7 @@ target_sources(crepe PUBLIC
 	ComponentManager.cpp
 	Component.cpp
 	Collider.cpp
+	ResourceManager.cpp
 	Resource.cpp
 )
 
@@ -13,6 +14,7 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES
 	Collider.h
 	ValueBroker.h
 	ValueBroker.hpp
+	ResourceManager.h
 	Resource.h
 )
 
diff --git a/src/crepe/ResourceManager.cpp b/src/crepe/ResourceManager.cpp
new file mode 100644
index 0000000..111b9e0
--- /dev/null
+++ b/src/crepe/ResourceManager.cpp
@@ -0,0 +1,36 @@
+#include <stdexcept>
+
+#include "util/Log.h"
+
+#include "ResourceManager.h"
+
+using namespace crepe;
+using namespace std;
+
+ResourceManager::~ResourceManager() { dbg_trace(); }
+ResourceManager::ResourceManager() { dbg_trace(); }
+
+void ResourceManager::clear() {
+	this->resources.clear();
+}
+
+// template <typename T>
+// T & ResourceManager::cache(const Asset & asset) {
+// 	dbg_trace();
+// 	static_assert(is_base_of<Resource, T>::value, "cache must recieve a derivative class of Resource");
+// 
+// 	if (!this->resources.contains(asset))
+// 		this->resources[asset] = make_unique<T>(asset);
+// 
+// 	Resource * resource = this->resources.at(asset).get();
+// 	T * concrete_resource = dynamic_cast<T *>(resource);
+// 
+// 	if (concrete_resource == nullptr)
+// 		throw runtime_error(format("ResourceManager: mismatch between requested type and actual type of resource ({})", asset.get_path()));
+// 
+// 	return *concrete_resource;
+// }
+// 
+// #include "facade/Sound.h"
+// template Sound & ResourceManager::cache(const Asset &);
+
diff --git a/src/crepe/ResourceManager.h b/src/crepe/ResourceManager.h
new file mode 100644
index 0000000..26a86a8
--- /dev/null
+++ b/src/crepe/ResourceManager.h
@@ -0,0 +1,76 @@
+#pragma once
+
+#include <memory>
+#include <unordered_map>
+
+#include "api/Asset.h"
+
+#include "Component.h"
+#include "Resource.h"
+
+namespace crepe {
+
+
+/**
+ * \brief The ResourceManager is responsible for storing and managing assets over
+ * multiple scenes.
+ * 
+ * The ResourceManager ensures that assets are loaded once and can be accessed
+ * across different scenes. It caches assets to avoid reloading them every time
+ * a scene is loaded. Assets are retained in memory until the ResourceManager is
+ * destroyed, at which point the cached assets are cleared.
+ */
+class ResourceManager {
+public:
+	ResourceManager(); // dbg_trace
+	virtual ~ResourceManager(); // dbg_trace
+
+private:
+	template <typename Resource>
+	Resource & get_internal(const Component & component, const Asset & asset);
+
+	template <typename Resource>
+	const Asset & get_source(const Component & component) const;
+
+	//! A cache that holds all the assets, accessible by their file path, over multiple scenes.
+	std::unordered_map<const Asset, std::unique_ptr<Resource>> resources;
+
+public:
+	/**
+	 * \brief Caches an asset by loading it from the given file path.
+	 *
+	 * \param file_path The path to the asset file to load.
+	 * \param reload If true, the asset will be reloaded from the file, even if
+	 * it is already cached.
+	 * \tparam T The type of asset to cache (e.g., texture, sound, etc.).
+	 * 
+	 * \return A reference to the resource
+	 * 
+	 * This template function caches the asset at the given file path. If the
+	 * asset is already cached, the existing instance will be returned.
+	 * Otherwise, the concrete resource will be instantiated and added to the
+	 * cache.
+	 */
+	template <typename Resource>
+	void cache(const Asset & asset, bool persistent = false);
+
+	template <typename Component>
+	void cache(const Component & component, bool persistent = false);
+
+	// void resman.cache<Resource>(Asset, Lifetime);
+	// void resman.cache(Component, Asset, Lifetime);
+
+	template <typename Resource, typename Component>
+	Resource & get(const Component & component);
+
+	//! Clear the resource cache
+	void clear();
+};
+
+class Sound;
+class AudioSource;
+template <>
+Sound & ResourceManager::get(const AudioSource & component);
+
+} // namespace crepe
+
diff --git a/src/crepe/api/AudioSource.h b/src/crepe/api/AudioSource.h
index 1264790..0950129 100644
--- a/src/crepe/api/AudioSource.h
+++ b/src/crepe/api/AudioSource.h
@@ -3,6 +3,7 @@
 #include "../Component.h"
 #include "../types.h"
 
+#include "GameObject.h"
 #include "Asset.h"
 
 namespace crepe {
diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt
index a2e21fa..ad82924 100644
--- a/src/crepe/api/CMakeLists.txt
+++ b/src/crepe/api/CMakeLists.txt
@@ -7,7 +7,6 @@ target_sources(crepe PUBLIC
 	Transform.cpp
 	Color.cpp
 	Texture.cpp
-	ResourceManager.cpp
 	Sprite.cpp
 	SaveManager.cpp
 	Config.cpp
@@ -39,7 +38,6 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES
 	Vector2.hpp
 	Color.h
 	Texture.h 
-	ResourceManager.h 
 	SaveManager.h
 	Scene.h
 	Metadata.h
diff --git a/src/crepe/api/Config.h b/src/crepe/api/Config.h
index 0c9d116..5bd6913 100644
--- a/src/crepe/api/Config.h
+++ b/src/crepe/api/Config.h
@@ -11,35 +11,12 @@ namespace crepe {
  * modified *before* execution is handed over from the game programmer to the engine (i.e. the
  * main loop is started).
  */
-class Config final {
-public:
+struct Config final {
 	//! Retrieve handle to global Config instance
 	static Config & get_instance();
 
-private:
-	Config() = default;
-	~Config() = default;
-	Config(const Config &) = default;
-	Config(Config &&) = default;
-	Config & operator=(const Config &) = default;
-	Config & operator=(Config &&) = default;
-
-public:
 	//! Logging-related settings
-	struct {
-		/**
-		 * \brief Log level
-		 *
-		 * Only messages with equal or higher priority than this value will be logged.
-		 */
-		Log::Level level = Log::Level::INFO;
-		/**
-		 * \brief Colored log output
-		 *
-		 * Enables log coloring using ANSI escape codes.
-		 */
-		bool color = true;
-	} log;
+	Log::Config log;
 
 	//! Save manager
 	struct {
diff --git a/src/crepe/api/ResourceManager.cpp b/src/crepe/api/ResourceManager.cpp
deleted file mode 100644
index 7877ed9..0000000
--- a/src/crepe/api/ResourceManager.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#include <stdexcept>
-
-#include "util/Log.h"
-
-#include "ResourceManager.h"
-
-using namespace crepe;
-using namespace std;
-
-ResourceManager & ResourceManager::get_instance() {
-	static ResourceManager instance;
-	return instance;
-}
-
-ResourceManager::~ResourceManager() { dbg_trace(); }
-ResourceManager::ResourceManager() { dbg_trace(); }
-
-void ResourceManager::clear() {
-	this->resources.clear();
-}
-
-template <typename T>
-T & ResourceManager::cache(const Asset & asset) {
-	dbg_trace();
-	static_assert(is_base_of<Resource, T>::value, "cache must recieve a derivative class of Resource");
-
-	if (!this->resources.contains(asset))
-		this->resources[asset] = make_unique<T>(asset);
-
-	Resource * resource = this->resources.at(asset).get();
-	T * concrete_resource = dynamic_cast<T *>(resource);
-
-	if (concrete_resource == nullptr)
-		throw runtime_error(format("ResourceManager: mismatch between requested type and actual type of resource ({})", asset.get_path()));
-
-	return *concrete_resource;
-}
-
-#include "../facade/Sound.h"
-template Sound & ResourceManager::cache(const Asset &);
-
diff --git a/src/crepe/api/ResourceManager.h b/src/crepe/api/ResourceManager.h
deleted file mode 100644
index efdd5c5..0000000
--- a/src/crepe/api/ResourceManager.h
+++ /dev/null
@@ -1,69 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <unordered_map>
-
-#include "Asset.h"
-#include "Resource.h"
-
-namespace crepe {
-
-class Sound;
-
-/**
- * \brief The ResourceManager is responsible for storing and managing assets over
- * multiple scenes.
- * 
- * The ResourceManager ensures that assets are loaded once and can be accessed
- * across different scenes. It caches assets to avoid reloading them every time
- * a scene is loaded. Assets are retained in memory until the ResourceManager is
- * destroyed, at which point the cached assets are cleared.
- */
-class ResourceManager {
-
-private:
-	//! A cache that holds all the assets, accessible by their file path, over multiple scenes.
-	std::unordered_map<const Asset, std::unique_ptr<Resource>> resources;
-
-private:
-	ResourceManager(); // dbg_trace
-	virtual ~ResourceManager(); // dbg_trace
-
-	ResourceManager(const ResourceManager &) = delete;
-	ResourceManager(ResourceManager &&) = delete;
-	ResourceManager & operator=(const ResourceManager &) = delete;
-	ResourceManager & operator=(ResourceManager &&) = delete;
-
-public:
-	/**
-	 * \brief Retrieves the singleton instance of the ResourceManager.
-	 *
-	 * \return A reference to the single instance of the ResourceManager.
-	 */
-	static ResourceManager & get_instance();
-
-public:
-	/**
-	 * \brief Caches an asset by loading it from the given file path.
-	 *
-	 * \param file_path The path to the asset file to load.
-	 * \param reload If true, the asset will be reloaded from the file, even if
-	 * it is already cached.
-	 * \tparam T The type of asset to cache (e.g., texture, sound, etc.).
-	 * 
-	 * \return A reference to the resource
-	 * 
-	 * This template function caches the asset at the given file path. If the
-	 * asset is already cached, the existing instance will be returned.
-	 * Otherwise, the concrete resource will be instantiated and added to the
-	 * cache.
-	 */
-	template <typename T>
-	T & cache(const Asset & asset);
-
-	//! Clear the resource cache
-	void clear();
-};
-
-} // namespace crepe
-
diff --git a/src/crepe/system/AudioSystem.cpp b/src/crepe/system/AudioSystem.cpp
index b7ac1f2..6c30b85 100644
--- a/src/crepe/system/AudioSystem.cpp
+++ b/src/crepe/system/AudioSystem.cpp
@@ -47,7 +47,7 @@ void AudioSystem::update() {
 		 *   using the same underlying instance of Sound (esp. w/
 		 *   play/pause/retrigger behavior).
 		 */
-		Sound & sound = this->resman.cache<Sound>(component.source);
+		// Sound & sound = this->resource_manager.get<Sound>(component);
 
 		// TODO: lots of state diffing
 	}
diff --git a/src/crepe/system/AudioSystem.h b/src/crepe/system/AudioSystem.h
index d0b4f9a..d3d5aeb 100644
--- a/src/crepe/system/AudioSystem.h
+++ b/src/crepe/system/AudioSystem.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "../facade/SoundContext.h"
-#include "../api/ResourceManager.h"
+#include "../ResourceManager.h"
 
 #include "System.h"
 
@@ -14,7 +14,7 @@ public:
 
 private:
 	SoundContext context {};
-	ResourceManager & resman = ResourceManager::get_instance();
+	ResourceManager resource_manager {};
 };
 
 } // namespace crepe
diff --git a/src/crepe/util/Log.cpp b/src/crepe/util/Log.cpp
index 84d80a8..bc86c7e 100644
--- a/src/crepe/util/Log.cpp
+++ b/src/crepe/util/Log.cpp
@@ -25,7 +25,7 @@ string Log::prefix(const Level & level) {
 }
 
 void Log::log(const Level & level, const string & msg) {
-	auto & cfg = Config::get_instance();
+	auto & cfg = crepe::Config::get_instance();
 	if (level < cfg.log.level) return;
 
 	string out = Log::prefix(level) + msg;
diff --git a/src/crepe/util/Log.h b/src/crepe/util/Log.h
index fc0bb3a..914145a 100644
--- a/src/crepe/util/Log.h
+++ b/src/crepe/util/Log.h
@@ -77,6 +77,22 @@ private:
 	 * \return Colored message severity prefix string
 	 */
 	static std::string prefix(const Level & level);
+
+public:
+	struct Config {
+		/**
+		 * \brief Log level
+		 *
+		 * Only messages with equal or higher priority than this value will be logged.
+		 */
+		Level level = INFO;
+		/**
+		 * \brief Colored log output
+		 *
+		 * Enables log coloring using ANSI escape codes.
+		 */
+		bool color = true;
+	};
 };
 
 } // namespace crepe
diff --git a/src/test/EventTest.cpp b/src/test/EventTest.cpp
index b0e6c9c..a21a851 100644
--- a/src/test/EventTest.cpp
+++ b/src/test/EventTest.cpp
@@ -37,7 +37,6 @@ public:
 
 TEST_F(EventManagerTest, EventSubscription) {
 	EventHandler<KeyPressEvent> key_handler = [](const KeyPressEvent & e) {
-		std::cout << "Key Event Triggered" << std::endl;
 		return true;
 	};
 
diff --git a/src/test/ResourceManagerTest.cpp b/src/test/ResourceManagerTest.cpp
index 3fc9ebd..f57c419 100644
--- a/src/test/ResourceManagerTest.cpp
+++ b/src/test/ResourceManagerTest.cpp
@@ -1,52 +1,101 @@
 #include <gtest/gtest.h>
 
+#define private public
+#define protected public
+
 #include <crepe/util/Log.h>
-#include <crepe/api/Config.h>
-#include <crepe/api/ResourceManager.h>
+#include <crepe/ResourceManager.h>
+#include <crepe/api/GameObject.h>
+#include <crepe/Component.h>
+#include <crepe/ComponentManager.h>
 
 using namespace std;
 using namespace crepe;
 using namespace testing;
 
+class TestComponent : public Component {
+public:
+	TestComponent(game_object_id_t id, const Asset & asset)
+		: Component(id),
+		  source(asset) {}
+	const Asset source;
+};
+
+class TestResource : public Resource {
+public:
+	static unsigned instances;
+
+public:
+	const unsigned instance;
+	TestResource(const Asset & src)
+		: Resource(src),
+		  instance(this->instances++) { }
+};
+unsigned TestResource::instances = 0;
+
+template <>
+TestResource & ResourceManager::get(const TestComponent & component) {
+	return this->get_internal<TestResource>(component, component.source);
+}
+
 class ResourceManagerTest : public Test {
 public:
-	ResourceManager & resman = ResourceManager::get_instance();
-	Config & cfg = Config::get_instance();
+	ResourceManager resource_manager{};
+
+	static constexpr const char * ASSET_LOCATION = "asset/texture/img.png";
+
+	TestComponent a{0, ASSET_LOCATION};
+	TestComponent b{1, ASSET_LOCATION};
 
+private:
 	void SetUp() override {
-		resman.clear();
+		TestResource::instances = 0;
 	}
 };
 
-TEST_F(ResourceManagerTest, Main) {
-	// NOTE: there is no way (that I know of) to ensure the last cache call
-	// allocates the new Sound instance in a different location than the first,
-	// so this test should be verified manually using these print statements and
-	// debug trace messages.
-	cfg.log.level = Log::Level::TRACE;
-
-	Asset path1 = "mwe/audio/sfx1.wav";
-	Asset path2 = "mwe/audio/sfx1.wav";
-	ASSERT_EQ(path1, path2);
-
-	Sound * ptr1 = nullptr;
-	Sound * ptr2 = nullptr;
-	{
-		Log::logf(Log::Level::DEBUG, "Get first sound (constructor call)");
-		Sound & sound = resman.cache<Sound>(path1);
-		ptr1 = &sound;
-	}
-	{
-		Log::logf(Log::Level::DEBUG, "Get same sound (NO constructor call)");
-		Sound & sound = resman.cache<Sound>(path2);
-		ptr2 = &sound;
-	}
-	EXPECT_EQ(ptr1, ptr2);
+TEST_F(ResourceManagerTest, Uncached) {
+	TestResource & res_1 = resource_manager.get<TestResource>(a); // 1
+	TestResource & res_2 = resource_manager.get<TestResource>(a); // 1
+	TestResource & res_3 = resource_manager.get<TestResource>(b); // 2
+	TestResource & res_4 = resource_manager.get<TestResource>(b); // 2
+
+	ASSERT_EQ(res_1, res_2);
+	ASSERT_EQ(res_3, res_4);
+	EXPECT_NE(res_1, res_3);
+
+	EXPECT_EQ(TestResource::instances, 2);
+}
+
+// TODO: per GameObject / Component
+TEST_F(ResourceManagerTest, PerComponent) {
+	resource_manager.cache(a);
+	resource_manager.cache(b);
+
+	TestResource & res_1 = resource_manager.get<TestResource>(a); // 1
+	TestResource & res_2 = resource_manager.get<TestResource>(a); // 1
+	TestResource & res_3 = resource_manager.get<TestResource>(b); // 2
+	TestResource & res_4 = resource_manager.get<TestResource>(b); // 2
+
+	ASSERT_EQ(res_1, res_2);
+	ASSERT_EQ(res_3, res_4);
+	EXPECT_NE(res_1, res_3);
+
+	EXPECT_EQ(TestResource::instances, 2);
+}
+
+TEST_F(ResourceManagerTest, PerAsset) {
+	resource_manager.cache(ASSET_LOCATION);
+	EXPECT_EQ(TestResource::instances, 1);
+
+	TestResource & res_1 = resource_manager.get<TestResource>(a); // 1
+	TestResource & res_2 = resource_manager.get<TestResource>(a); // 1
+	TestResource & res_3 = resource_manager.get<TestResource>(b); // 1
+	TestResource & res_4 = resource_manager.get<TestResource>(b); // 1
 
-	Log::logf(Log::Level::DEBUG, "Clear cache (destructor call)");
-	resman.clear();
+	EXPECT_EQ(res_1, res_2);
+	EXPECT_EQ(res_2, res_3);
+	EXPECT_EQ(res_3, res_4);
 
-	Log::logf(Log::Level::DEBUG, "Get first sound again (constructor call)");
-	Sound & sound = resman.cache<Sound>(path1);
+	EXPECT_EQ(TestResource::instances, 1);
 }
 
diff --git a/src/test/main.cpp b/src/test/main.cpp
index e03a989..54f74fd 100644
--- a/src/test/main.cpp
+++ b/src/test/main.cpp
@@ -1,8 +1,4 @@
 #include <gtest/gtest.h>
-
-#define protected public
-#define private public
-
 #include <crepe/api/Config.h>
 
 using namespace crepe;
@@ -11,12 +7,14 @@ using namespace testing;
 class GlobalConfigReset : public EmptyTestEventListener {
 public:
 	Config & cfg = Config::get_instance();
-	Config cfg_default = Config();
 
 	// This function is called before each test
 	void OnTestStart(const TestInfo &) override {
-		cfg = cfg_default;
-		cfg.log.level = Log::Level::WARNING;
+		cfg = {
+			.log = {
+				.level = Log::Level::WARNING,
+			},
+		};
 	}
 };
 
-- 
cgit v1.2.3


From e4be73051a68b552c44280bbe9836dd4f02972d8 Mon Sep 17 00:00:00 2001
From: Loek Le Blansch <loek@pipeframe.xyz>
Date: Fri, 29 Nov 2024 20:35:17 +0100
Subject: audio system kinda working

---
 src/crepe/api/AudioSource.cpp     |  1 -
 src/crepe/api/AudioSource.h       |  2 --
 src/crepe/api/Config.h            | 25 +++++++++++++++++++++++--
 src/crepe/facade/Sound.h          |  7 +------
 src/crepe/facade/SoundContext.cpp | 31 +++++++++++++++++++++++++++++--
 src/crepe/facade/SoundContext.h   | 10 ++++++++++
 src/crepe/system/AudioSystem.cpp  | 30 ++++++++++++++++++++++++------
 src/crepe/system/AudioSystem.h    |  2 +-
 src/crepe/util/Log.cpp            |  2 +-
 src/crepe/util/Log.h              | 16 ----------------
 10 files changed, 89 insertions(+), 37 deletions(-)

(limited to 'src/crepe/api/Config.h')

diff --git a/src/crepe/api/AudioSource.cpp b/src/crepe/api/AudioSource.cpp
index 4baac9a..c646aeb 100644
--- a/src/crepe/api/AudioSource.cpp
+++ b/src/crepe/api/AudioSource.cpp
@@ -15,6 +15,5 @@ void AudioSource::play(bool looping) {
 
 void AudioSource::stop() {
 	this->playing = false;
-	this->rewind = true;
 }
 
diff --git a/src/crepe/api/AudioSource.h b/src/crepe/api/AudioSource.h
index 9d76f0b..8dc1645 100644
--- a/src/crepe/api/AudioSource.h
+++ b/src/crepe/api/AudioSource.h
@@ -44,8 +44,6 @@ private:
 
 	//! If this source is playing audio
 	bool playing = false;
-	//! Rewind the sample location
-	bool rewind = false;
 
 private:
 	//! AudioSystem::ComponentPrivate
diff --git a/src/crepe/api/Config.h b/src/crepe/api/Config.h
index 693400a..7be506e 100644
--- a/src/crepe/api/Config.h
+++ b/src/crepe/api/Config.h
@@ -1,8 +1,10 @@
 #pragma once
 
+#include <string>
+
 #include "../util/Log.h"
+
 #include "types.h"
-#include <string>
 
 namespace crepe {
 
@@ -18,7 +20,20 @@ struct Config final {
 	static Config & get_instance();
 
 	//! Logging-related settings
-	Log::Config log;
+	struct {
+		/**
+		 * \brief Log level
+		 *
+		 * Only messages with equal or higher priority than this value will be logged.
+		 */
+		Log::Level level = Log::Level::INFO;
+		/**
+		 * \brief Colored log output
+		 *
+		 * Enables log coloring using ANSI escape codes.
+		 */
+		bool color = true;
+	} log;
 
 	//! Save manager
 	struct {
@@ -62,6 +77,12 @@ struct Config final {
 		 */
 		std::string root_pattern = ".crepe-root";
 	} asset;
+
+	//! Audio system settings
+	struct {
+		//! Max amount of simultanious voices
+		unsigned int voices = 32;
+	} audio;
 };
 
 } // namespace crepe
diff --git a/src/crepe/facade/Sound.h b/src/crepe/facade/Sound.h
index 10d7c3c..35bccdb 100644
--- a/src/crepe/facade/Sound.h
+++ b/src/crepe/facade/Sound.h
@@ -20,13 +20,8 @@ public:
 	Sound(const Asset & src);
 	~Sound(); // dbg_trace
 
-	class Handle {
-	private:
+	struct Handle {
 		SoLoud::handle handle;
-		float volume = 1.0f;
-		bool looping = false;
-
-		friend class SoundContext;
 	};
 
 private:
diff --git a/src/crepe/facade/SoundContext.cpp b/src/crepe/facade/SoundContext.cpp
index b65dfb2..3e9a3d1 100644
--- a/src/crepe/facade/SoundContext.cpp
+++ b/src/crepe/facade/SoundContext.cpp
@@ -6,10 +6,37 @@ using namespace crepe;
 
 SoundContext::SoundContext() {
 	dbg_trace();
-	engine.init();
+	this->engine.init();
+	this->engine.setMaxActiveVoiceCount(this->config.audio.voices);
 }
 
 SoundContext::~SoundContext() {
 	dbg_trace();
-	engine.deinit();
+	this->engine.deinit();
 }
+
+Sound::Handle SoundContext::play(Sound & resource) {
+	return {
+		.handle = this->engine.play(resource.sample, this->default_volume),
+	};
+}
+
+void SoundContext::stop(Sound::Handle & handle) {
+	this->engine.stop(handle.handle);
+}
+
+void SoundContext::set_volume(Sound & resource, Sound::Handle & handle, float volume) {
+	this->engine.setVolume(handle.handle, volume);
+	this->default_volume = volume;
+}
+
+void SoundContext::set_loop(Sound & resource, Sound::Handle & handle, bool loop) {
+	this->engine.setLooping(handle.handle, loop);
+}
+
+bool SoundContext::get_playing(Sound::Handle & handle) {
+	// See Soloud::stopVoice_internal in soloud/src/core/soloud_core_voiceops.cpp for why this is
+	// the correct method to use here (samples are currently never paused)
+	return this->engine.isValidVoiceHandle(handle.handle);
+}
+
diff --git a/src/crepe/facade/SoundContext.h b/src/crepe/facade/SoundContext.h
index 286ced8..e02977e 100644
--- a/src/crepe/facade/SoundContext.h
+++ b/src/crepe/facade/SoundContext.h
@@ -2,6 +2,8 @@
 
 #include <soloud/soloud.h>
 
+#include "../api/Config.h"
+
 #include "Sound.h"
 
 namespace crepe {
@@ -22,9 +24,17 @@ public:
 	SoundContext & operator=(const SoundContext &) = delete;
 	SoundContext & operator=(SoundContext &&) = delete;
 
+	Sound::Handle play(Sound & resource);
+	void stop(Sound::Handle &);
+	void set_volume(Sound &, Sound::Handle &, float);
+	void set_loop(Sound &, Sound::Handle &, bool);
+	bool get_playing(Sound::Handle &);
 
 private:
 	SoLoud::Soloud engine;
+	float default_volume = 1.0f;
+
+	Config & config = Config::get_instance();
 };
 
 } // namespace crepe
diff --git a/src/crepe/system/AudioSystem.cpp b/src/crepe/system/AudioSystem.cpp
index 191dbbb..98aff58 100644
--- a/src/crepe/system/AudioSystem.cpp
+++ b/src/crepe/system/AudioSystem.cpp
@@ -20,6 +20,7 @@ void AudioSystem::update() {
 		if (component.private_data.empty()) {
 			auto & data = component.private_data.set<ComponentPrivate>();
 			this->update_last(component, data);
+			data.last_playing = false; // always start
 		}
 		auto & data = component.private_data.get<ComponentPrivate>();
 
@@ -29,18 +30,35 @@ void AudioSystem::update() {
 	}
 }
 
-void AudioSystem::diff_update(AudioSource & component, const ComponentPrivate & data, Sound & resource) {
+void AudioSystem::diff_update(AudioSource & component, ComponentPrivate & data, Sound & resource) {
 	bool update_playing = component.playing != data.last_playing;
 	bool update_volume = component.volume != data.last_volume;
 	bool update_loop = component.loop != data.last_loop;
 	bool update_active = component.active != data.last_active;
 
-	if (update_active)
-	if (component.rewind) {
-		component.playing = false;
-		// this->context.rewind(resource, data.handle);
+	if (update_active) {
+		if (component.active) {
+			update_playing = true;
+			if (component.play_on_awake)
+				component.playing = true;
+		} else {
+			this->context.stop(data.handle);
+			return;
+		}
+	}
+	if (!component.active) return;
+	if (update_playing) {
+		if (component.playing) data.handle = this->context.play(resource);
+		else this->context.stop(data.handle);
+	} else {
+		component.playing = this->context.get_playing(data.handle);
+	}
+	if (update_volume) {
+		this->context.set_volume(resource, data.handle, component.volume);
+	}
+	if (update_loop) {
+		this->context.set_loop(resource, data.handle, component.loop);
 	}
-
 }
 
 void AudioSystem::update_last(const AudioSource & component, ComponentPrivate & data) {
diff --git a/src/crepe/system/AudioSystem.h b/src/crepe/system/AudioSystem.h
index 4650178..3404878 100644
--- a/src/crepe/system/AudioSystem.h
+++ b/src/crepe/system/AudioSystem.h
@@ -34,7 +34,7 @@ private:
 
 	void update_last(const AudioSource & component, ComponentPrivate & data);
 
-	void diff_update(AudioSource & component, const ComponentPrivate & data, Sound & resource);
+	void diff_update(AudioSource & component, ComponentPrivate & data, Sound & resource);
 
 private:
 	SoundContext context {};
diff --git a/src/crepe/util/Log.cpp b/src/crepe/util/Log.cpp
index bc86c7e..84d80a8 100644
--- a/src/crepe/util/Log.cpp
+++ b/src/crepe/util/Log.cpp
@@ -25,7 +25,7 @@ string Log::prefix(const Level & level) {
 }
 
 void Log::log(const Level & level, const string & msg) {
-	auto & cfg = crepe::Config::get_instance();
+	auto & cfg = Config::get_instance();
 	if (level < cfg.log.level) return;
 
 	string out = Log::prefix(level) + msg;
diff --git a/src/crepe/util/Log.h b/src/crepe/util/Log.h
index 914145a..fc0bb3a 100644
--- a/src/crepe/util/Log.h
+++ b/src/crepe/util/Log.h
@@ -77,22 +77,6 @@ private:
 	 * \return Colored message severity prefix string
 	 */
 	static std::string prefix(const Level & level);
-
-public:
-	struct Config {
-		/**
-		 * \brief Log level
-		 *
-		 * Only messages with equal or higher priority than this value will be logged.
-		 */
-		Level level = INFO;
-		/**
-		 * \brief Colored log output
-		 *
-		 * Enables log coloring using ANSI escape codes.
-		 */
-		bool color = true;
-	};
 };
 
 } // namespace crepe
-- 
cgit v1.2.3