resonance 0.1.0

A modular game engine. Heavy work in progress.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104


use super::backend::AudioBackend;
use super::systems::*;
use crate::app::{Engine, Plugin, Stage};

pub struct AudioPluginConfig {
    pub enable_spatial_audio: bool,
    pub enable_doppler: bool,
}

impl Default for AudioPluginConfig {
    fn default() -> Self {
        Self {
            enable_spatial_audio: true,
            enable_doppler: true,
        }
    }
}

pub struct AudioPlugin {
    config: AudioPluginConfig,
}

impl AudioPlugin {

    pub fn new() -> Self {
        Self {
            config: AudioPluginConfig::default(),
        }
    }

    pub fn with_config(config: AudioPluginConfig) -> Self {
        Self { config }
    }

    pub fn without_spatial_audio(mut self) -> Self {
        self.config.enable_spatial_audio = false;
        self
    }

    pub fn without_doppler(mut self) -> Self {
        self.config.enable_doppler = false;
        self
    }
}

impl Default for AudioPlugin {
    fn default() -> Self {
        Self::new()
    }
}

impl Plugin for AudioPlugin {
    fn build(&self, engine: &mut Engine) {

        match AudioBackend::new() {
            Ok(backend) => {
                engine.world.insert_resource(backend);
                log::info!("Audio backend initialized");
            }
            Err(e) => {
                log::error!("Failed to initialize audio backend: {}", e);
                return;
            }
        }

        if let Some(schedule) = engine.schedules.get_mut(Stage::PreUpdate) {
            schedule.add_systems((
                handle_play_on_spawn,
                initialize_audio_sources,
            ));
        }

        if let Some(schedule) = engine.schedules.get_mut(Stage::Update) {
            schedule.add_systems((
                play_audio_sources,
                handle_audio_state_changes,
            ));
        }

        if self.config.enable_spatial_audio {
            if let Some(schedule) = engine.schedules.get_mut(Stage::Update) {
                schedule.add_systems(update_spatial_audio);
            }
            log::info!("3D spatial audio enabled");
        }

        if self.config.enable_doppler && self.config.enable_spatial_audio {
            if let Some(schedule) = engine.schedules.get_mut(Stage::Update) {
                schedule.add_systems(apply_doppler_effect);
            }
            log::info!("Doppler effect enabled");
        }

        if let Some(schedule) = engine.schedules.get_mut(Stage::PostUpdate) {
            schedule.add_systems((
                cleanup_one_shot_audio,
                cleanup_audio_backend,
            ));
        }

        log::info!("AudioPlugin initialized");
    }
}