nsys-fmod-utils 0.1.0

FMOD utilities
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

//! Sample bank

use fmod;
use vec_map::VecMap;

/// A vecmap of FMOD sounds.
#[derive(Debug, PartialEq)]
pub struct Sampler {
  samples : VecMap <fmod::Sound>,
  system  : fmod::System
}

pub type IndexType = u16;
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct Id (pub IndexType);

impl Sampler {
  pub fn new (system : &fmod::System) -> Self {
    Sampler {
      samples: VecMap::new(),
      system:  system.clone()
    }
  }

  #[inline]
  pub fn load (&mut self, files : VecMap <String>) {
    let samples = files.into_iter().map (|(i, s)|
      ( i,
        self.system.create_sound_from_file (&s, fmod::Mode::DEFAULT, None)
          .unwrap()
      )
    ).collect::<VecMap <fmod::Sound>>();
    self.samples.extend (samples);
  }
  #[inline]
  pub fn load_memory (&mut self, files : VecMap <&[u8]>) {
    let samples = files.into_iter().map (|(i, bytes)|
      ( i,
        self.system.create_sound_from_memory (bytes, fmod::Mode::DEFAULT, None)
          .unwrap()
      )
    ).collect::<VecMap <fmod::Sound>>();
    self.samples.extend (samples);
  }
  #[inline]
  pub fn load_pcm (&mut self, pcms : VecMap <&[i16]>) {
    let samples = pcms.into_iter().map (|(i, pcm)|
      ( i,
        self.system.create_sound_from_pcm (pcm, fmod::Mode::DEFAULT, None)
          .unwrap()
      )
    ).collect::<VecMap <fmod::Sound>>();
    self.samples.extend (samples);
  }
  #[inline]
  pub fn get (&self, id : Id) -> Option <&fmod::Sound> {
    self.samples.get (id.0 as usize)
  }
  #[inline]
  pub fn get_mut (&mut self, id : Id) -> Option <&mut fmod::Sound> {
    self.samples.get_mut (id.0 as usize)
  }
  #[inline]
  pub fn set (&mut self, sample : fmod::Sound, id : Id) {
    let _ = self.samples.insert (id.0 as usize, sample);
  }
  #[inline]
  pub fn remove (&mut self, id : Id) -> Option <fmod::Sound> {
    self.samples.remove (id.0 as usize)
  }
  /// Start playing on a fresh channel; the priority system will "steal" an
  /// existing channel if there are no free channels.
  ///
  /// If no mode is given, the current mode for the sound (`sound.get_mode()`)
  /// will be used. Providing a mode will set the mode on the sound.
  #[inline]
  pub fn play (&mut self,
    id            : Id,
    mode          : Option <fmod::Mode>,
    channel_group : Option <&mut fmod::ChannelGroup>,
  ) -> fmod::Channel {
    let sample = self.samples.get_mut (id.0 as usize).unwrap();
    mode.map (|mode| sample.set_mode (mode).unwrap());
    sample.play (channel_group, false).unwrap()
  }
  /// "Play" on a fresh channel with 'paused = true'
  #[inline]
  pub fn cue (&mut self,
    id            : Id,
    mode          : Option <fmod::Mode>,
    channel_group : Option <&mut fmod::ChannelGroup>
  ) -> fmod::Channel {
    let sample = self.samples.get_mut (id.0 as usize).unwrap();
    mode.map (|mode| sample.set_mode (mode).unwrap());
    sample.play (channel_group, true).unwrap()
  }
}

impl Id {
  #[inline]
  pub fn index (&self) -> usize {
    self.0 as usize
  }
}