horizontal_mixer 0.1.3

horizontal mixer in Rust using Kira for audio playback
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
130
131
132
133

#![doc = include_str!("../readme.md")]


use std::time::Duration;

use kira::{
    manager::{backend::DefaultBackend, AudioManager, AudioManagerSettings},
    modulator::tweener::{TweenerBuilder, TweenerHandle},
    sound::static_sound::{StaticSoundData, StaticSoundSettings},
    tween::{ModulatorMapping, Tween, Value},
    Volume,
};

pub struct HorizontalMixer {
    manager: AudioManager<DefaultBackend>,
    vol_tween: TweenerHandle,
    pub track_1: StaticSoundData,
    pub track_2: StaticSoundData,
    pub current_track: i8,
    fade_time: Duration
}

impl HorizontalMixer {
    pub fn new(path_1: &str, path_2: &str, fade_time: Duration, loop_mus: bool) -> Self {
        let mut manager =
            AudioManager::<DefaultBackend>::new(AudioManagerSettings::default()).unwrap();

        let vol_tween = manager
            .add_modulator(TweenerBuilder { initial_value: 0.0 })
            .unwrap();

        if loop_mus {
            let track_1 = StaticSoundData::from_file(
                path_1,
                StaticSoundSettings::new()
                    .volume(Value::from_modulator(
                        &vol_tween,
                        ModulatorMapping {
                            input_range: (0.0, 1.0),
                            output_range: (Volume::Amplitude(1.0), Volume::Amplitude(0.0)),
                            ..Default::default()
                        },
                    ))
                    .loop_region(0.0..),
            )
            .unwrap();

            let track_2 = StaticSoundData::from_file(
                path_2,
                StaticSoundSettings::new()
                    .volume(Value::from_modulator(
                        &vol_tween,
                        ModulatorMapping {
                            input_range: (0.0, 1.0),
                            output_range: (Volume::Amplitude(0.0), Volume::Amplitude(1.0)),
                            ..Default::default()
                        },
                    ))
                    .loop_region(0.0..),
            )
            .unwrap();

            return HorizontalMixer {
                manager,
                vol_tween,
                track_1,
                track_2,
                current_track: 0,
                fade_time,
            }
        }

        let track_1 = StaticSoundData::from_file(
            path_1,
            StaticSoundSettings::new().volume(Value::from_modulator(
                &vol_tween,
                ModulatorMapping {
                    input_range: (0.0, 1.0),
                    output_range: (Volume::Amplitude(1.0), Volume::Amplitude(0.0)),
                    ..Default::default()
                },
            )),
        )
        .unwrap();

        let track_2 = StaticSoundData::from_file(
            path_2,
            StaticSoundSettings::new().volume(Value::from_modulator(
                &vol_tween,
                ModulatorMapping {
                    input_range: (0.0, 1.0),
                    output_range: (Volume::Amplitude(0.0), Volume::Amplitude(1.0)),
                    ..Default::default()
                },
            )),
        )
        .unwrap();

        HorizontalMixer {
            manager,
            vol_tween,
            track_1,
            track_2,
            current_track: 0,
            fade_time,
        }
    }

    pub fn switch_track(&mut self, which_track: i8) {
        if which_track < 2 {
            self.current_track = which_track;
        } else {
            self.current_track = 0;
        }

        self.vol_tween.set(
            self.current_track as f64,
            Tween {
                duration: self.fade_time,
                ..Default::default()
            },
        ).unwrap();
    }

    pub fn toggle_track(&mut self) {
        self.switch_track(self.current_track + 1);
    }

    pub fn play(&mut self) {
        self.manager.play(self.track_1.clone()).unwrap();
        self.manager.play(self.track_2.clone()).unwrap();
    }
}