craydate 0.1.7

A safe Rust API for the Playdate hand held gaming system.
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
134
135
136
137
138
139
140
141
142
143
144

use crate::clamped_float::ClampedFloatInclusive;

/// A volume with two channels: left and right.
#[derive(Debug, Default)]
pub struct StereoVolume {
  /// The left channel volume, a value between 0 and 1.
  pub left: Volume,
  /// The right channel volume, a value between 0 and 1.
  pub right: Volume,
}
impl StereoVolume {
  /// Constructs a new StereoVolume from `f32` volume levels that will be clamped to within 0 and 1.
  pub fn new(left: f32, right: f32) -> Self {
    StereoVolume {
      left: Volume::new(left),
      right: Volume::new(right),
    }
  }
  /// Constructs a new StereoVolume with the given already-clamped channel volume levels.
  pub fn with_clamped(
    left: ClampedFloatInclusive<0, 1>,
    right: ClampedFloatInclusive<0, 1>,
  ) -> Self {
    StereoVolume {
      left: Volume::with_clamped(left),
      right: Volume::with_clamped(right),
    }
  }
  /// Constructs a StereoVolume with both channels set to 0.
  pub fn zero() -> Self {
    Self::new(0.0, 0.0)
  }
  /// Constructs a StereoVolume with both channels set to 1.
  pub fn one() -> Self {
    Self::new(1.0, 1.0)
  }
}

/// A volume, which is a value between 0 and 1. Setting it to a value outside the valid range will
/// result in the value being clamped to within 0 and 1.
#[derive(Debug, Default)]
#[repr(transparent)]
pub struct Volume(ClampedFloatInclusive<0, 1>);
impl Volume {
  /// Constructs a new Volume from a `f32` volume level that will be clamped to within 0 and 1.
  pub fn new(vol: f32) -> Self {
    Volume(vol.into())
  }
  /// Constructs a new Volume with the given already-clamped volume level.
  pub fn with_clamped(vol: ClampedFloatInclusive<0, 1>) -> Self {
    Volume(vol)
  }
  /// Constructs a Volume set to 0.
  pub fn zero() -> Self {
    Self::new(0.0)
  }
  /// Constructs a Volume set to 1.
  pub fn one() -> Self {
    Self::new(1.0)
  }

  pub(crate) fn as_mut_ptr(&mut self) -> *mut f32 {
    self.0.as_mut_ptr()
  }

  /// Converts to an `f32` without bounds.
  pub fn to_f32(self) -> f32 {
    self.0.to_f32()
  }
}

impl From<f32> for Volume {
  fn from(f: f32) -> Self {
    Volume::new(f)
  }
}
impl From<Volume> for f32 {
  fn from(v: Volume) -> Self {
    v.0.into()
  }
}
impl core::fmt::Display for Volume {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    self.0.fmt(f)
  }
}

impl core::ops::Add for Volume {
  type Output = Self;

  fn add(self, rhs: Self) -> Self::Output {
    Self::with_clamped(self.0.add(rhs.0))
  }
}
impl core::ops::Sub for Volume {
  type Output = Self;

  fn sub(self, rhs: Self) -> Self::Output {
    Self::with_clamped(self.0.sub(rhs.0))
  }
}
impl core::ops::Mul for Volume {
  type Output = Self;

  fn mul(self, rhs: Self) -> Self::Output {
    Self::with_clamped(self.0.mul(rhs.0))
  }
}
impl core::ops::Div for Volume {
  type Output = Self;

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

impl core::ops::Add<f32> for Volume {
  type Output = Self;

  fn add(self, rhs: f32) -> Self::Output {
    Self::with_clamped(self.0.add(rhs))
  }
}
impl core::ops::Sub<f32> for Volume {
  type Output = Self;

  fn sub(self, rhs: f32) -> Self::Output {
    Self::with_clamped(self.0.sub(rhs))
  }
}
impl core::ops::Mul<f32> for Volume {
  type Output = Self;

  fn mul(self, rhs: f32) -> Self::Output {
    Self::with_clamped(self.0.mul(rhs))
  }
}
impl core::ops::Div<f32> for Volume {
  type Output = Self;

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