Audio framework. (#32)

* Add audio service.

* Groundwork for weapon fire and enemy death SFX.

* Fix Android CI.

Author: karnkaul

.github/workflows/ci.yml

@@ -57,6 +57,6 @@ jobs:
             tar xvzf jdk-17_linux-x64_bin.tar.gz -C /opt
       - name: build
         run: |
-            export JAVA_HOME=/opt/jdk-17.0.10
+            export JAVA_HOME=$(find /opt -name "jdk-17.*")
             cd src/android
             ./gradlew assembleDebug

CMakeLists.txt

@@ -11,7 +11,7 @@ include(FetchContent)
 FetchContent_Declare(
   bave
   GIT_REPOSITORY https://github.com/karnkaul/bave
-  GIT_TAG 8717d1eafd2ac581c7b90fa3af384eb66cd7896a # v0.4.8
+  GIT_TAG ff3978f8431649007d3309db513d3de3e72fe823 # v0.4.9
   SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ext/bave"
 )
 

assets/sfx/bubble.wav

@@ -15,7 +15,10 @@
       ],
       "spawn_rate": 2,
       "initial_health": 2,
-      "death_emitter": "particles/explode.json"
+      "death_emitter": "particles/explode.json",
+      "death_sfx": [
+        "sfx/bubble.wav"
+      ]
     }
   ]
 }

assets/worlds/playground.json

@@ -31,6 +31,12 @@ auto AssetList::add_particle_emitter(std::string uri) -> AssetList& {
 	return *this;
 }
 
+auto AssetList::add_audio_clip(std::string uri) -> AssetList& {
+	if (uri.empty()) { return *this; }
+	m_audio_clips.insert(std::move(uri));
+	return *this;
+}
+
 auto AssetList::read_world_spec(std::string_view const uri) -> WorldSpec {
 	if (uri.empty()) { return {}; }
 
@@ -51,6 +57,7 @@ auto AssetList::read_world_spec(std::string_view const uri) -> WorldSpec {
 
 	for (auto const& enemy_factory : json["enemy_factories"].array_view()) {
 		add_particle_emitter(enemy_factory["death_emitter"].as<std::string>());
+		for (auto const& death_sfx : enemy_factory["death_sfx"].array_view()) { add_audio_clip(death_sfx.as<std::string>()); }
 		ret.enemy_factories.push_back(enemy_factory);
 	}
 
@@ -70,6 +77,7 @@ auto AssetList::build_stage_0(AssetLoader& asset_loader) const -> AsyncExec::Sta
 	auto ret = AsyncExec::Stage{};
 	for (auto const& texture : m_textures) { ret.push_back(asset_loader.make_load_texture(texture.uri, texture.mip_map)); }
 	for (auto const& font : m_fonts) { ret.push_back(asset_loader.make_load_font(font)); }
+	for (auto const& audio_clip : m_audio_clips) { ret.push_back(asset_loader.make_load_audio_clip(audio_clip)); }
 	return ret;
 }
 

src/spaced/spaced/game/asset_list.cpp

@@ -16,6 +16,7 @@ class AssetList {
 	auto add_texture(std::string uri, bool mip_map = false) -> AssetList&;
 	auto add_font(std::string uri) -> AssetList&;
 	auto add_particle_emitter(std::string uri) -> AssetList&;
+	auto add_audio_clip(std::string uri) -> AssetList&;
 
 	auto read_world_spec(std::string_view uri) -> WorldSpec;
 
@@ -40,5 +41,6 @@ class AssetList {
 	std::set<Tex> m_textures{};
 	std::set<std::string> m_fonts{};
 	std::set<std::string> m_emitters{};
+	std::set<std::string> m_audio_clips{};
 };
 } // namespace spaced

src/spaced/spaced/game/asset_list.hpp

@@ -53,6 +53,11 @@ auto AssetLoader::make_load_particle_emitter(std::string uri, bool const reload)
 	return make_load_task(std::move(uri), reload, load);
 }
 
+auto AssetLoader::make_load_audio_clip(std::string uri, bool const reload) -> LoadTask {
+	auto const load = [](Loader const& loader, std::string_view const uri) { return loader.load_audio_clip(uri); };
+	return make_load_task(std::move(uri), reload, load);
+}
+
 template <typename FuncT>
 auto AssetLoader::make_load_task(std::string uri, bool reload, FuncT load) const -> LoadTask {
 	return [impl = m_impl, uri = std::move(uri), reload, load] {

src/spaced/spaced/game/asset_loader.cpp

@@ -16,6 +16,7 @@ class AssetLoader {
 	[[nodiscard]] auto make_load_texture(std::string uri, bool mip_map = false, bool reload = false) -> LoadTask;
 	[[nodiscard]] auto make_load_texture_atlas(std::string uri, bool mip_map = false, bool reload = false) -> LoadTask;
 	[[nodiscard]] auto make_load_particle_emitter(std::string uri, bool reload = false) -> LoadTask;
+	[[nodiscard]] auto make_load_audio_clip(std::string uri, bool reload = false) -> LoadTask;
 
   private:
 	template <typename FuncT>

src/spaced/spaced/game/asset_loader.hpp

@@ -13,17 +13,18 @@ using bave::random_in_range;
 using bave::Seconds;
 
 BasicCreepFactory::BasicCreepFactory(NotNull<Services const*> services, NotNull<IEnemyDeathListener*> listener, dj::Json const& json)
-	: m_services(services), m_listener(listener) {
+	: IEnemyFactory(services), m_listener(listener) {
 	for (auto const& tint : json["tints"].array_view()) { tints.push_back(tint.as<std::string>()); }
 	if (auto const in_death_emitter = services->get<Resources>().get<ParticleEmitter>(json["death_emitter"].as_string())) { death_emitter = *in_death_emitter; }
 	spawn_rate = Seconds{json["spawn_rate"].as<float>(spawn_rate.count())};
 	initial_health = json["initial_health"].as<float>(initial_health);
+	for (auto const& death_sfx : json["death_sfx"].array_view()) { m_death_sfx.push_back(death_sfx.as<std::string>()); }
 }
 
 auto BasicCreepFactory::spawn_enemy() -> std::unique_ptr<Enemy> {
-	auto ret = std::make_unique<Creep>(*m_services, m_listener);
+	auto ret = std::make_unique<Creep>(get_services(), m_listener);
 	if (!tints.empty()) {
-		auto const& rgbas = m_services->get<Styles>().rgbas;
+		auto const& rgbas = get_services().get<Styles>().rgbas;
 		auto const tint_index = random_in_range(std::size_t{}, tints.size() - 1);
 		ret->shape.tint = rgbas[tints.at(tint_index)];
 		ret->health = initial_health;

src/spaced/spaced/game/enemies/basic_creep_factory.cpp

@@ -23,7 +23,6 @@ class BasicCreepFactory : public IEnemyFactory {
   private:
 	void do_inspect() final;
 
-	bave::NotNull<Services const*> m_services;
 	bave::NotNull<IEnemyDeathListener*> m_listener;
 	bave::Seconds m_elapsed{};
 };

src/spaced/spaced/game/enemies/basic_creep_factory.hpp

@@ -0,0 +1,10 @@
+#include <spaced/game/enemy_factory.hpp>
+#include <spaced/services/audio.hpp>
+
+namespace spaced {
+using bave::NotNull;
+
+IEnemyFactory::IEnemyFactory(NotNull<Services const*> services) : m_services(services), m_audio(&services->get<IAudio>()) {}
+
+void IEnemyFactory::play_death_sfx() { m_audio->play_any_sfx(m_death_sfx); }
+} // namespace spaced

src/spaced/spaced/game/enemy_factory.cpp

@@ -1,21 +1,37 @@
 #pragma once
 #include <bave/graphics/particle_system.hpp>
 #include <spaced/game/enemy.hpp>
+#include <string>
+#include <vector>
 
 namespace spaced {
+class IAudio;
+
 class IEnemyFactory : public bave::Polymorphic {
   public:
+	explicit IEnemyFactory(bave::NotNull<Services const*> services);
+
 	[[nodiscard]] virtual auto get_type_name() const -> std::string_view = 0;
 	[[nodiscard]] virtual auto spawn_enemy() -> std::unique_ptr<Enemy> = 0;
 	[[nodiscard]] virtual auto get_death_emitter() const -> bave::ParticleEmitter const& = 0;
 
+	void play_death_sfx();
+
 	virtual auto tick(bave::Seconds dt) -> bool = 0;
 
 	void inspect() {
 		if constexpr (bave::debug_v) { do_inspect(); }
 	}
 
+  protected:
+	[[nodiscard]] auto get_services() const -> Services const& { return *m_services; }
+
+	std::vector<std::string> m_death_sfx{};
+
   private:
 	virtual void do_inspect() {}
+
+	bave::NotNull<Services const*> m_services;
+	bave::NotNull<IAudio*> m_audio;
 };
 } // namespace spaced

src/spaced/spaced/game/enemy_factory.hpp

@@ -42,6 +42,7 @@ void EnemySpawner::explode_at(glm::vec2 const position) {
 	auto& emitter = m_death_emitters.emplace_back(m_factory->get_death_emitter());
 	emitter.config.respawn = false;
 	emitter.set_position(position);
+	m_factory->play_death_sfx();
 }
 
 void EnemySpawner::do_inspect() {

src/spaced/spaced/game/enemy_spawner.cpp

@@ -73,6 +73,7 @@ void Player::setup(WorldSpec::Player const& spec) {
 	m_exhaust.pre_warm();
 
 	if (auto const death = resources.get<ParticleEmitter>(spec.death_emitter)) { m_death_source = *death; }
+	m_death_source.config.respawn = false;
 }
 
 void Player::set_y(float const y) { ship.transform.position.y = y; }
@@ -99,7 +100,6 @@ void Player::on_death() {
 	health = 0.0f;
 	m_death = m_death_source;
 	m_death->set_position(ship.transform.position);
-	m_death->config.respawn = false;
 }
 
 void Player::do_inspect() {

src/spaced/spaced/game/player.cpp

@@ -1,9 +1,18 @@
 #include <bave/imgui/im_text.hpp>
 #include <spaced/game/weapon.hpp>
+#include <spaced/services/audio.hpp>
 
 namespace spaced {
 using bave::im_text;
 
+Weapon::Weapon(Services const& services, std::string name) : m_log{std::move(name)}, m_layout(&services.get<ILayout>()), m_audio(&services.get<IAudio>()) {}
+
+auto Weapon::fire(glm::vec2 const muzzle_position) -> std::unique_ptr<Round> {
+	auto ret = do_fire(muzzle_position);
+	if (ret) { m_audio->play_any_sfx(m_fire_sfx); }
+	return ret;
+}
+
 void Weapon::do_inspect() {
 	if constexpr (bave::imgui_v) { im_text("rounds remaining: {}", get_rounds_remaining()); }
 }

src/spaced/spaced/game/weapon.cpp

@@ -6,15 +6,17 @@
 #include <spaced/services/services.hpp>
 
 namespace spaced {
+class IAudio;
+
 class Weapon : public bave::Polymorphic {
   public:
 	using Round = IWeaponRound;
 
-	explicit Weapon(Services const& services, std::string name) : m_log{std::move(name)}, m_layout(&services.get<ILayout>()) {}
+	explicit Weapon(Services const& services, std::string name);
 
 	[[nodiscard]] auto get_rounds_remaining() const -> int { return rounds < 0 ? 1 : rounds; }
 
-	virtual auto fire(glm::vec2 muzzle_position) -> std::unique_ptr<Round> = 0;
+	auto fire(glm::vec2 muzzle_position) -> std::unique_ptr<Round>;
 	[[nodiscard]] virtual auto is_idle() const -> bool = 0;
 
 	virtual void tick(bave::Seconds dt) = 0;
@@ -28,11 +30,14 @@ class Weapon : public bave::Polymorphic {
   protected:
 	[[nodiscard]] auto get_layout() const -> ILayout const& { return *m_layout; }
 
+	virtual auto do_fire(glm::vec2 muzzle_position) -> std::unique_ptr<Round> = 0;
 	virtual void do_inspect();
 
 	bave::Logger m_log{};
+	std::vector<std::string> m_fire_sfx{};
 
   private:
 	bave::NotNull<ILayout const*> m_layout;
+	bave::NotNull<IAudio*> m_audio;
 };
 } // namespace spaced

src/spaced/spaced/game/weapon.hpp

@@ -102,15 +102,6 @@ GunBeam::GunBeam(Services const& services) : Weapon(services, "GunBeam") {
 	config.beam_tint = rgbas.get_or("gun_beam", rgbas["grey"]);
 }
 
-auto GunBeam::fire(glm::vec2 const muzzle_position) -> std::unique_ptr<Round> {
-	if (!is_idle() || m_reload_remain > 0s || rounds == 0) { return {}; }
-
-	if (rounds > 0) { --rounds; }
-	m_fire_remain = config.fire_duration;
-	m_reload_remain = 0s;
-	return std::make_unique<LaserCharge>(&get_layout(), config, muzzle_position);
-}
-
 void GunBeam::tick(Seconds const dt) {
 	if (m_fire_remain > 0s) {
 		m_fire_remain -= dt;
@@ -122,6 +113,15 @@ void GunBeam::tick(Seconds const dt) {
 	if (m_reload_remain > 0s) { m_reload_remain -= dt; }
 }
 
+auto GunBeam::do_fire(glm::vec2 const muzzle_position) -> std::unique_ptr<Round> {
+	if (!is_idle() || m_reload_remain > 0s || rounds == 0) { return {}; }
+
+	if (rounds > 0) { --rounds; }
+	m_fire_remain = config.fire_duration;
+	m_reload_remain = 0s;
+	return std::make_unique<LaserCharge>(&get_layout(), config, muzzle_position);
+}
+
 void GunBeam::do_inspect() {
 	if constexpr (bave::imgui_v) {
 		im_text("type: GunBeam");

src/spaced/spaced/game/weapons/gun_beam.cpp

@@ -14,13 +14,13 @@ class GunBeam final : public Weapon {
 
 	explicit GunBeam(Services const& services);
 
-	auto fire(glm::vec2 muzzle_position) -> std::unique_ptr<Round> final;
 	[[nodiscard]] auto is_idle() const -> bool final { return m_fire_remain <= 0s; }
 	void tick(bave::Seconds dt) final;
 
 	Config config{};
 
   private:
+	auto do_fire(glm::vec2 muzzle_position) -> std::unique_ptr<Round> final;
 	void do_inspect() final;
 
 	bave::Seconds m_fire_remain{};

src/spaced/spaced/game/weapons/gun_beam.hpp

@@ -7,20 +7,22 @@ using bave::im_text;
 using bave::Rgba;
 using bave::Seconds;
 
-GunKinetic::GunKinetic(Services const& services) : Weapon(services, "GunKinetic") { projectile_config.tint = services.get<Styles>().rgbas["black"]; }
+GunKinetic::GunKinetic(Services const& services) : Weapon(services, "GunKinetic"), m_audio(&services.get<IAudio>()) {
+	projectile_config.tint = services.get<Styles>().rgbas["black"];
+}
+
+void GunKinetic::tick(Seconds const dt) {
+	if (m_reload_remain > 0s) { m_reload_remain -= dt; }
+}
 
-auto GunKinetic::fire(glm::vec2 const muzzle_position) -> std::unique_ptr<Round> {
+auto GunKinetic::do_fire(glm::vec2 const muzzle_position) -> std::unique_ptr<Round> {
 	if (m_reload_remain > 0s || rounds == 0) { return {}; }
 
 	if (rounds > 0) { --rounds; }
 	m_reload_remain = reload_delay;
 	return std::make_unique<Projectile>(&get_layout(), projectile_config, muzzle_position);
 }
 
-void GunKinetic::tick(Seconds const dt) {
-	if (m_reload_remain > 0s) { m_reload_remain -= dt; }
-}
-
 void GunKinetic::do_inspect() {
 	if constexpr (bave::imgui_v) {
 		im_text("type: GunKinetic");

src/spaced/spaced/game/weapons/gun_kinetic.cpp

@@ -1,13 +1,13 @@
 #pragma once
 #include <spaced/game/weapon.hpp>
 #include <spaced/game/weapons/projectile.hpp>
+#include <spaced/services/audio.hpp>
 
 namespace spaced {
 class GunKinetic final : public Weapon {
   public:
 	explicit GunKinetic(Services const& services);
 
-	auto fire(glm::vec2 muzzle_position) -> std::unique_ptr<Round> final;
 	[[nodiscard]] auto is_idle() const -> bool final { return m_reload_remain <= 0s; }
 
 	void tick(bave::Seconds dt) final;
@@ -16,8 +16,10 @@ class GunKinetic final : public Weapon {
 	bave::Seconds reload_delay{0.25s};
 
   private:
+	auto do_fire(glm::vec2 muzzle_position) -> std::unique_ptr<Round> final;
 	void do_inspect() final;
 
 	bave::Seconds m_reload_remain{};
+	bave::NotNull<IAudio*> m_audio;
 };
 } // namespace spaced

src/spaced/spaced/game/weapons/gun_kinetic.hpp

@@ -17,13 +17,15 @@ class ResourceMap {
 
 	template <typename Type>
 	[[nodiscard]] auto contains(std::string_view const uri) const -> bool {
+		if (uri.empty()) { return false; }
 		auto const it = m_resources.find(uri);
 		if (it == m_resources.end()) { return false; }
 		return it->second->type_index == typeid(Type);
 	}
 
 	template <typename Type>
 	[[nodiscard]] auto get(std::string_view const uri, std::shared_ptr<Type> const& fallback = {}) const -> std::shared_ptr<Type> {
+		if (uri.empty()) { return fallback; }
 		auto const it = m_resources.find(uri);
 		if (it == m_resources.end()) { return fallback; }
 		auto const& resource = it->second;

src/spaced/spaced/resource_map.hpp

@@ -0,0 +1,28 @@
+#pragma once
+#include <bave/core/random.hpp>
+#include <bave/core/time.hpp>
+#include <spaced/services/service.hpp>
+#include <span>
+#include <string_view>
+
+namespace spaced {
+class IAudio : public IService {
+  public:
+	[[nodiscard]] virtual auto get_sfx_gain() const -> float = 0;
+	virtual void set_sfx_gain(float gain) = 0;
+
+	[[nodiscard]] virtual auto get_music_gain() const -> float = 0;
+	virtual void set_music_gain(float gain) = 0;
+
+	virtual void play_sfx(std::string_view uri) = 0;
+	virtual void play_music(std::string_view uri, bave::Seconds crossfade = 1s) = 0;
+	virtual void stop_music() = 0;
+
+	void play_any_sfx(std::span<std::string const> uris) {
+		if (uris.empty()) { return; }
+		if (uris.size() == 1) { return play_sfx(uris.front()); }
+		auto const index = bave::random_in_range(std::size_t{}, uris.size() - 1);
+		play_sfx(uris[index]);
+	}
+};
+} // namespace spaced

src/spaced/spaced/services/audio.hpp

@@ -2,6 +2,7 @@
 #include <bave/json_io.hpp>
 #include <bave/loader.hpp>
 #include <spaced/scenes/home.hpp>
+#include <spaced/services/audio.hpp>
 #include <spaced/services/gamepad_provider.hpp>
 #include <spaced/services/layout.hpp>
 #include <spaced/services/resources.hpp>
@@ -13,6 +14,9 @@
 namespace spaced {
 namespace {
 using bave::App;
+using bave::AudioClip;
+using bave::AudioDevice;
+using bave::AudioStreamer;
 using bave::Gamepad;
 using bave::KeyInput;
 using bave::Loader;
@@ -23,19 +27,7 @@ using bave::PointerTap;
 using bave::Rect;
 using bave::RenderDevice;
 using bave::RenderView;
-
-struct SceneSwitcherImpl : ISceneSwitcher {
-	App& app;				  // NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members)
-	Services const& services; // NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members)
-	std::unique_ptr<Scene> next_scene{};
-
-	explicit SceneSwitcherImpl(App& app, Services const& services) : app(app), services(services) {}
-
-	void switch_to_scene(std::unique_ptr<Scene> new_scene) final { next_scene = std::move(new_scene); }
-
-	[[nodiscard]] auto get_app() const -> App& final { return app; }
-	[[nodiscard]] auto get_services() const -> Services const& final { return services; }
-};
+using bave::Seconds;
 
 struct GamepadProvider : IGamepadProvider {
 	bave::App& app; // NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members)
@@ -72,8 +64,50 @@ struct Layout : ILayout {
 
 	void set_framebuffer_size(glm::vec2 const size) final { framebuffer_size = size; }
 };
+
+struct Audio : IAudio {
+	NotNull<AudioDevice*> audio_device;
+	NotNull<AudioStreamer*> audio_streamer;
+	NotNull<Resources const*> resources;
+
+	explicit Audio(NotNull<AudioDevice*> audio_device, NotNull<AudioStreamer*> audio_streamer, NotNull<Resources const*> resources)
+		: audio_device(audio_device), audio_streamer(audio_streamer), resources(resources) {}
+
+	[[nodiscard]] auto get_sfx_gain() const -> float final { return audio_device->sfx_gain; }
+	void set_sfx_gain(float const gain) final { audio_device->sfx_gain = gain; }
+
+	[[nodiscard]] auto get_music_gain() const -> float final { return audio_streamer->gain; }
+	void set_music_gain(float const gain) final { audio_streamer->gain = gain; }
+
+	void play_sfx(std::string_view const uri) final {
+		auto const clip = resources->get<AudioClip>(uri);
+		if (!clip) { return; }
+		audio_device->play_once(*clip);
+	}
+
+	void play_music(std::string_view const uri, Seconds const crossfade) final {
+		auto const clip = resources->get<AudioClip>(uri);
+		if (!clip) { return; }
+		audio_streamer->play(clip, crossfade);
+	}
+
+	void stop_music() final { audio_streamer->stop(); }
+};
 } // namespace
 
+struct SceneSwitcher : ISceneSwitcher {
+	App& app;				  // NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members)
+	Services const& services; // NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members)
+	std::unique_ptr<Scene> next_scene{};
+
+	explicit SceneSwitcher(App& app, Services const& services) : app(app), services(services) {}
+
+	void switch_to_scene(std::unique_ptr<Scene> new_scene) final { next_scene = std::move(new_scene); }
+
+	[[nodiscard]] auto get_app() const -> App& final { return app; }
+	[[nodiscard]] auto get_services() const -> Services const& final { return services; }
+};
+
 void Spaced::set_bindings([[maybe_unused]] Serializer& serializer) {}
 
 Spaced::Spaced(App& app) : Driver(app), m_scene(std::make_unique<Scene>(app, m_services)) {
@@ -99,9 +133,10 @@ void Spaced::tick() {
 	m_layout->set_framebuffer_size(get_app().get_framebuffer_size());
 
 	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-static-cast-downcast)
-	if (auto& switcher = static_cast<SceneSwitcherImpl&>(m_services.get<ISceneSwitcher>()); switcher.next_scene) {
+	if (m_scene_switcher->next_scene) {
 		m_resources->clear();
-		m_scene = std::move(switcher.next_scene);
+		m_audio->stop_music();
+		m_scene = std::move(m_scene_switcher->next_scene);
 	}
 
 	m_scene->tick_frame(dt);
@@ -156,12 +191,16 @@ void Spaced::create_services() {
 	set_bindings(*serializer);
 	m_services.bind<Serializer>(std::move(serializer));
 
-	auto gamepad_provider = std::make_unique<GamepadProvider>(get_app());
-	m_services.bind<IGamepadProvider>(std::move(gamepad_provider));
+	m_services.bind<IGamepadProvider>(std::make_unique<GamepadProvider>(get_app()));
+
+	auto audio = std::make_unique<Audio>(&get_app().get_audio_device(), &get_app().get_audio_streamer(), m_resources);
+	m_audio = audio.get();
+	m_services.bind<IAudio>(std::move(audio));
 }
 
 void Spaced::set_scene() {
-	auto switcher = std::make_unique<SceneSwitcherImpl>(get_app(), m_services);
+	auto switcher = std::make_unique<SceneSwitcher>(get_app(), m_services);
+	m_scene_switcher = switcher.get();
 	switcher->switch_to<Home>();
 	m_services.bind<ISceneSwitcher>(std::move(switcher));
 }

src/spaced/spaced/spaced.cpp

@@ -6,6 +6,8 @@
 namespace spaced {
 class Serializer;
 struct Resources;
+class IAudio;
+struct SceneSwitcher;
 
 class Spaced : public bave::Driver {
   public:
@@ -31,7 +33,9 @@ class Spaced : public bave::Driver {
 	bave::Logger m_log{"Spaced"};
 	Services m_services{};
 	bave::Ptr<ILayout> m_layout{};
+	bave::Ptr<SceneSwitcher> m_scene_switcher{};
 	bave::Ptr<Resources> m_resources{};
+	bave::Ptr<IAudio> m_audio{};
 	std::unique_ptr<Scene> m_scene{};
 };
 } // namespace spaced