audionimbus 0.14.0

A safe wrapper around Steam Audio that provides spatial audio capabilities with realistic occlusion, reverb, and HRTF effects, accounting for physical attributes and scene geometry.
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

use super::{Point, Vector3};

#[cfg(feature = "bevy")]
use bevy::prelude::GlobalTransform;

/// A 3D coordinate system, expressed relative to a canonical coordinate system.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct CoordinateSystem {
    /// Unit vector pointing to the right (local +x axis).
    pub right: Vector3,

    /// Unit vector pointing upwards (local +y axis).
    pub up: Vector3,

    /// Unit vector pointing forwards (local -z axis).
    pub ahead: Vector3,

    /// The origin, relative to the canonical coordinate system.
    pub origin: Point,
}

impl Default for CoordinateSystem {
    fn default() -> Self {
        Self {
            right: Vector3::new(1.0, 0.0, 0.0),
            up: Vector3::new(0.0, 1.0, 0.0),
            ahead: Vector3::new(0.0, 0.0, 1.0),
            origin: Vector3::new(0.0, 0.0, 0.0),
        }
    }
}

impl From<CoordinateSystem> for audionimbus_sys::IPLCoordinateSpace3 {
    fn from(coordinate_system: CoordinateSystem) -> Self {
        Self {
            right: coordinate_system.right.into(),
            up: coordinate_system.up.into(),
            ahead: coordinate_system.ahead.into(),
            origin: coordinate_system.origin.into(),
        }
    }
}

impl From<audionimbus_sys::IPLCoordinateSpace3> for CoordinateSystem {
    fn from(coordinate_system: audionimbus_sys::IPLCoordinateSpace3) -> Self {
        Self {
            right: coordinate_system.right.into(),
            up: coordinate_system.up.into(),
            ahead: coordinate_system.ahead.into(),
            origin: coordinate_system.origin.into(),
        }
    }
}

#[cfg(feature = "bevy")]
impl From<GlobalTransform> for CoordinateSystem {
    fn from(global_transform: GlobalTransform) -> Self {
        Self {
            right: global_transform.right().to_array().into(),
            up: global_transform.up().to_array().into(),
            ahead: global_transform.forward().to_array().into(),
            origin: global_transform.translation().to_array().into(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_coordinate_system_default() {
        let cs = CoordinateSystem::default();
        assert_eq!(
            cs,
            CoordinateSystem {
                right: Vector3::new(1.0, 0.0, 0.0),
                up: Vector3::new(0.0, 1.0, 0.0),
                ahead: Vector3::new(0.0, 0.0, 1.0),
                origin: Vector3::new(0.0, 0.0, 0.0),
            }
        );
    }
}