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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! # Kira
//!
//! Kira is an audio library designed to help create expressive audio
//! for games. Besides the common features you'd expect from an audio
//! library, it provides interfaces for scripting audio events,
//! seamlessly looping complex pieces of music, smoothly changing
//! parameters, and more.
//!
//! ## Usage
//!
//! To use Kira, first create an [`AudioManager`](manager::AudioManager):
//! ```no_run
//! # use std::error::Error;
//! #
//! # use kira::manager::{AudioManager, AudioManagerSettings};
//! #
//! let mut audio_manager = AudioManager::new(AudioManagerSettings::default())?;
//! # Ok::<(), Box<dyn std::error::Error>>(())
//! ```
//!
//! All audio-related actions go through the [`AudioManager`](manager::AudioManager).
//!
//! ### Loading and playing a sound
//!
//! ```no_run
//! # use std::error::Error;
//! #
//! # use kira::{
//! # 	instance::InstanceSettings,
//! # 	manager::{AudioManager, AudioManagerSettings},
//! # 	sound::SoundSettings,
//! # };
//! #
//! # let mut audio_manager = AudioManager::new(AudioManagerSettings::default())?;
//! let mut sound_handle = audio_manager.load_sound("sound.ogg", SoundSettings::default())?;
//! sound_handle.play(InstanceSettings::default())?;
//! # Ok::<(), Box<dyn std::error::Error>>(())
//! ```
//!
//! ### Looping a song while preserving trailing sounds
//!
//! ```no_run
//! # use std::error::Error;
//! #
//! # use kira::{
//! # 	arrangement::{Arrangement, LoopArrangementSettings},
//! # 	instance::InstanceSettings,
//! # 	manager::{AudioManager, AudioManagerSettings},
//! # 	sound::SoundSettings,
//! # 	Tempo,
//! # };
//! #
//! # let mut audio_manager = AudioManager::new(AudioManagerSettings::default())?;
//! let sound_handle = audio_manager.load_sound(
//! 	"loop.ogg",
//! 	SoundSettings::new().semantic_duration(Tempo(128.0).beats_to_seconds(8.0)),
//! )?;
//! let mut arrangement_handle = audio_manager.add_arrangement(Arrangement::new_loop(
//! 	&sound_handle,
//! 	LoopArrangementSettings::default(),
//! ))?;
//! arrangement_handle.play(InstanceSettings::default())?;
//! # Ok::<(), Box<dyn std::error::Error>>(())
//! ```
//!
//! ### Scripting audio sequences
//!
//! This example will play a kick drum sound every 4 beats and emit an event
//! each time:
//!
//! ```no_run
//! # use std::error::Error;
//! #
//! # use kira::{
//! # 	instance::InstanceSettings,
//! # 	manager::{AudioManager, AudioManagerSettings},
//! # 	metronome::MetronomeSettings,
//! # 	sequence::{Sequence, SequenceInstanceSettings, SequenceSettings},
//! # 	sound::SoundSettings,
//! # 	Tempo,
//! # };
//! #
//! #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
//! enum CustomEvent {
//! 	Kick,
//! }
//!
//! # let mut audio_manager = AudioManager::new(AudioManagerSettings::default())?;
//! let kick_sound_handle = audio_manager.load_sound("kick.wav", SoundSettings::default())?;
//! let mut metronome_handle =
//! 	audio_manager.add_metronome(MetronomeSettings::new().tempo(Tempo(150.0)))?;
//! audio_manager.start_sequence(
//! 	{
//! 		let mut sequence = Sequence::new(SequenceSettings::default());
//! 		sequence.start_loop();
//! 		sequence.play(&kick_sound_handle, InstanceSettings::default());
//! 		sequence.emit(CustomEvent::Kick);
//! 		sequence.wait(kira::Duration::Beats(1.0));
//! 		sequence
//! 	},
//! 	SequenceInstanceSettings::new().metronome(&metronome_handle),
//! )?;
//! metronome_handle.start()?;
//! # Ok::<(), Box<dyn std::error::Error>>(())
//! ```

#![warn(missing_docs)]

pub mod arrangement;
pub mod audio_stream;
mod command;
mod duration;
mod frame;
pub mod group;
pub mod instance;
pub mod manager;
pub mod metronome;
pub mod mixer;
pub mod parameter;
mod playable;
pub mod sequence;
pub mod sound;
mod static_container;
mod tempo;
mod util;
mod value;

pub use command::producer::CommandError;
pub use duration::Duration;
pub use frame::Frame;
pub use playable::PlayableId;
pub use tempo::Tempo;
pub use value::{CachedValue, Value};