oml-audio 0.4.1

Very basic, and thin abstraction of audio handling meant for games.
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
105
106
107
108
109


use crate::FileLoader;

use crate::sound::DropMode;

use crate::{
	WavFile,
	WavPlayer,
};

use std::collections::VecDeque;

#[derive(Debug)]
pub struct SoundPoolMiniaudio {
	debug:			bool,
	wav_file:		WavFile,
	players:		VecDeque< WavPlayer >,
	drop_mode:		DropMode,
}

impl SoundPoolMiniaudio {

	pub fn new() -> Self {
		Self {
			debug:			false,
			wav_file:		WavFile::new(),
			players:		VecDeque::new(),
			drop_mode:		DropMode::Oldest,
		}
	}

	pub fn load( &mut self, fileloader: &mut impl FileLoader, name: &str, number: u16 ) -> bool {
		let filename = format!("{}{}", name, ".wav");
		self.wav_file.load( fileloader, &filename );

		for n in 0..number {
			let player = WavPlayer::new();
			self.players.push_back( player );
		}

		true
	}

	pub fn play( &mut self ) {
		if let Some( mut player ) = if let Some( player ) = self.players.front( ) {
			let playing: bool = player.is_playing();
			if self.debug { dbg!(playing); }
			if !playing {
				if self.debug { println!("Using new player!"); }
				self.players.pop_front()
			} else {
				if self.debug { println!("No new player found!"); }
				match self.drop_mode {
					DropMode::Newest => None,
					DropMode::Oldest => {
						if self.debug { println!("Reusing old player!"); }
//							let _: () = msg_send![ player, stop ];
//							let _: () = msg_send![ player, setCurrentTime: 0.0 ];
						self.players.pop_front()
					},
					DropMode::OlderThan => {
						/*
						let current_time: f64 = msg_send![ player, currentTime ];
						if current_time > 0.5 {
//								let _: () = msg_send![ player, stop ];
//								let _: () = msg_send![ player, setCurrentTime: 0.0 ];
							self.players.pop_front()
						} else {
							None
						}
						*/
						None
					},
				}
			}
		} else {
			if self.debug { println!("No player found!"); }
			None
		} {
			if self.debug { println!("Playing!"); }
			player.stop();
			player.set_current_time( 0.0 );
			player.play();
			self.players.push_back( player );
		}
	}

	pub fn update( &mut self, _time_step: f64 ) {
	}

	pub fn next_sample( &mut self ) -> f32 {
		let mut v = 0.0;
		for p in self.players.iter_mut() {
			if p.is_playing() {
				v += p.next_sample( &self.wav_file );
			}
		}
		v
	}

	pub fn enable_debug( &mut self ) {
		self.debug = true;
	}
	pub fn disable_debug( &mut self ) {
		self.debug = false;
	}

}