kira 0.12.0

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

use std::ops::{
	Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Rem, RemAssign, Sub, SubAssign,
};

use crate::{Value, tween::Tweenable};

#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(transparent))]
/**

An amount to blend the "dry" and "wet" outputs from an effect.

The "dry" signal is the audio before the effect is applied.
The "wet" signal is the audio after the effect is applied.

Valid mix values range from `0.0` to `1.0`, where `0.0` is
the dry signal only, `1.0` is the wet signal only, and `0.5`
is an equal mix of both.
*/
pub struct Mix(pub f32);

impl Mix {
	/// Only output the dry signal.
	pub const DRY: Self = Self(0.0);
	/// Only output the wet signal.
	pub const WET: Self = Self(1.0);
}

impl Tweenable for Mix {
	fn interpolate(a: Self, b: Self, amount: f64) -> Self {
		Self(Tweenable::interpolate(a.0, b.0, amount))
	}
}

impl From<f32> for Mix {
	fn from(value: f32) -> Self {
		Self(value)
	}
}

impl From<f32> for Value<Mix> {
	fn from(value: f32) -> Self {
		Self::Fixed(Mix(value))
	}
}

impl From<Mix> for Value<Mix> {
	fn from(value: Mix) -> Self {
		Self::Fixed(value)
	}
}

impl Add<Mix> for Mix {
	type Output = Mix;

	fn add(self, rhs: Mix) -> Self::Output {
		Self(self.0 + rhs.0)
	}
}

impl AddAssign<Mix> for Mix {
	fn add_assign(&mut self, rhs: Mix) {
		self.0 += rhs.0;
	}
}

impl Sub<Mix> for Mix {
	type Output = Mix;

	fn sub(self, rhs: Mix) -> Self::Output {
		Self(self.0 - rhs.0)
	}
}

impl SubAssign<Mix> for Mix {
	fn sub_assign(&mut self, rhs: Mix) {
		self.0 -= rhs.0;
	}
}

impl Mul<f32> for Mix {
	type Output = Mix;

	fn mul(self, rhs: f32) -> Self::Output {
		Self(self.0 * rhs)
	}
}

impl MulAssign<f32> for Mix {
	fn mul_assign(&mut self, rhs: f32) {
		self.0 *= rhs;
	}
}

impl Div<f32> for Mix {
	type Output = Mix;

	fn div(self, rhs: f32) -> Self::Output {
		Self(self.0 / rhs)
	}
}

impl DivAssign<f32> for Mix {
	fn div_assign(&mut self, rhs: f32) {
		self.0 /= rhs;
	}
}

impl Neg for Mix {
	type Output = Mix;

	fn neg(self) -> Self::Output {
		Self(-self.0)
	}
}

impl Rem<f32> for Mix {
	type Output = Mix;

	fn rem(self, rhs: f32) -> Self::Output {
		Self(self.0 % rhs)
	}
}

impl RemAssign<f32> for Mix {
	fn rem_assign(&mut self, rhs: f32) {
		self.0 %= rhs;
	}
}