Feat/better mixer

Cargo.toml

@@ -4,3 +4,16 @@ members = [
     "ashen",
     "engine",
 ]
+
+
+[profile.perf]
+inherits = "release"
+codegen-units = 1
+incremental = false
+lto = "fat"
+opt-level = 3
+panic = "abort"
+
+[profile.release]
+debug = true
+overflow-checks = true

engine/Cargo.toml

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+bitflags = "2.4.2"
 const_format = "0.2.32"
 fixed = "1.24.0"
 flate2 = "1.0.28"
@@ -16,6 +17,7 @@ sealed = "0.5.0"
 thiserror = "1.0.56"
 
 [dev-dependencies]
+assert_approx_eq = "1.1.0"
 eyre = "0.6.8"
 image = "0.24.8"
 

engine/src/asset/color_map.rs

@@ -1,6 +1,7 @@
+use std::{mem, ops::Deref};
+
 use super::{extension::*, AssetParser};
 use crate::{error, utils::nom::*};
-use std::{mem, ops::Deref};
 
 const COLORS_COUNT: usize = 256;
 const SHADES_COUNT: usize = 32;
@@ -14,7 +15,7 @@
 }
 
 impl Color {
     pub fn from_12_bit(color: u16) -> Self {
         // TODO(nenikitov): return result.
         assert!(color <= 0xFFF, "12 bit color is smaller than 0xFFF");
 
@@ -90,9 +91,10 @@
 
 #[cfg(test)]
 mod tests {
+    use std::cell::LazyCell;
+
     use super::*;
     use crate::utils::{format::*, test::*};
-    use std::cell::LazyCell;
 
     #[test]
     fn shade_works() -> eyre::Result<()> {

engine/src/asset/gamma_table.rs

@@ -1,6 +1,7 @@
+use std::mem;
+
 use super::{extension::*, AssetParser};
 use crate::{error, utils::nom::*};
-use std::mem;
 
 const ROWS_COUNT: usize = 256;
 const COLS_COUNT: usize = 101;
@@ -47,12 +48,13 @@ impl AssetParser<Pack> for GammaTable {
 
 #[cfg(test)]
 mod tests {
+    use std::cell::LazyCell;
+
     use super::*;
     use crate::{
         asset::color_map::Color,
         utils::{format::*, test::*},
     };
-    use std::cell::LazyCell;
 
     const GAMMA_TABLE_DATA: LazyCell<Vec<u8>> = deflated_file!("00.dat");
 

engine/src/asset/model/mod.rs

@@ -1,15 +1,18 @@
 mod dat;
 
+use dat::{
+    frame::{ModelFrame, ModelSpecs},
+    header::ModelHeader,
+    sequence::ModelSequence,
+    triangle::{ModelTriangle, TextureDimensions},
+};
+
 use super::{
     extension::*,
     texture::{Texture, TextureSize},
     AssetParser,
 };
 use crate::utils::nom::*;
-use dat::{
-    frame::ModelFrame, frame::ModelSpecs, header::ModelHeader, sequence::ModelSequence,
-    triangle::ModelTriangle, triangle::TextureDimensions,
-};
 
 pub struct Model {
     pub texture: Texture,
@@ -69,6 +72,14 @@ impl AssetParser<Pack> for Model {
 
 #[cfg(test)]
 mod tests {
+    use std::{
+        cell::LazyCell,
+        fmt::{Display, Formatter},
+        path::PathBuf,
+    };
+
+    use itertools::Itertools;
+
     use super::{
         dat::{frame::ModelVertex, triangle::ModelPoint},
         *,
@@ -77,12 +88,6 @@ mod tests {
         asset::color_map::{Color, ColorMap, PaletteTexture},
         utils::test::*,
     };
-    use itertools::Itertools;
-    use std::{
-        cell::LazyCell,
-        fmt::{Display, Formatter},
-        path::PathBuf,
-    };
 
     const COLOR_MAP_DATA: LazyCell<Vec<u8>> = deflated_file!("01.dat");
     const MODEL_DATA: LazyCell<Vec<u8>> = deflated_file!("0E-deflated.dat");

engine/src/asset/pack_file.rs

@@ -23,7 +23,7 @@
     const HEADER: &'static str = "PMAN";
     const COPYRIGHT_LENGTH: usize = 56;
 
     pub fn new(input: &[u8]) -> Result<Self> {
         let (copyright, entries) = {
             let (input, (copyright, total_entries)) = Self::header(input)?;
             let (input, (headers)) = Self::entry_headers(input, total_entries)?;
@@ -86,9 +86,10 @@
 
 #[cfg(test)]
 mod tests {
+    use std::{cell::LazyCell, io, path::PathBuf};
+
     use super::*;
     use crate::utils::{compression::decompress, test::*};
-    use std::{cell::LazyCell, io, path::PathBuf};
 
     #[test]
     fn header_works() -> eyre::Result<()> {

engine/src/asset/pack_info.rs

@@ -1,6 +1,7 @@
+use std::ops::Index;
+
 use super::{extension::*, AssetParser};
 use crate::utils::nom::*;
-use std::ops::Index;
 
 #[derive(Debug)]
 pub struct PackInfo {

engine/src/asset/skybox.rs

@@ -38,12 +38,13 @@ impl AssetParser<Pack> for Skybox {
 
 #[cfg(test)]
 mod tests {
+    use std::cell::LazyCell;
+
     use super::*;
     use crate::{
         asset::color_map::PaletteTexture,
         utils::{format::*, test::*},
     };
-    use std::cell::LazyCell;
 
     const SKYBOX_DATA: LazyCell<Vec<u8>> = deflated_file!("3C.dat");
 

engine/src/asset/sound/dat/finetune.rs

@@ -0,0 +1,124 @@
+use std::{
+    ops::{Add, AddAssign, Neg, Sub},
+    sync::LazyLock,
+};
+
+use crate::utils::iterator::CollectArray;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct FineTune {
+    cents: i32,
+}
+
+static PITCH_FACTORS: LazyLock<[f64; FineTune::MAX]> = LazyLock::new(|| {
+    // TODO(nenikitov): This formula is from the game
+    // And it's very magic.
+    // Maybe simplify it or at least name constants.
+    (0..FineTune::MAX)
+        .map(|i| i as f64)
+        .map(|cents| {
+            1.0 / (2f64.powf(cents / (12.0 * FineTune::CENTS_PER_NOTE as f64))
+            * 8363.0
+            // TODO(nenikitov): This is `2^20`, which is divided by `2048` and `8192` results in `1/16`
+            * 1048576.0
+                / 16000.0
+                / 2048.0
+                / 8192.0)
+        })
+        .collect_array()
+});
+
+impl FineTune {
+    const CENTS_PER_NOTE: i32 = 128;
+    const MAX: usize = 15488;
+
+    pub const fn new(cents: i32) -> Self {
+        Self { cents }
+    }
+
+    pub const fn from_note(note: i32) -> Self {
+        FineTune::new(note * Self::CENTS_PER_NOTE)
+    }
+
+    pub fn pitch_factor(self) -> f64 {
+        PITCH_FACTORS[(self.cents as usize).clamp(0, Self::MAX)]
+    }
+
+    pub fn cents(self) -> i32 {
+        self.cents
+    }
+
+    pub fn note(self) -> i32 {
+        self.cents / Self::CENTS_PER_NOTE
+    }
+}
+
+impl Add for FineTune {
+    type Output = FineTune;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        FineTune::new(self.cents.saturating_add(rhs.cents))
+    }
+}
+
+impl AddAssign for FineTune {
+    fn add_assign(&mut self, rhs: Self) {
+        self.cents = self.cents.saturating_add(rhs.cents);
+    }
+}
+
+impl Sub for FineTune {
+    type Output = FineTune;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        FineTune::new(self.cents.saturating_sub(rhs.cents))
+    }
+}
+
+impl Neg for FineTune {
+    type Output = FineTune;
+
+    fn neg(self) -> Self::Output {
+        FineTune::new(-self.cents)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use assert_approx_eq::assert_approx_eq;
+
+    use super::*;
+
+    #[test]
+    fn from_note_works() {
+        assert_eq!(
+            FineTune {
+                cents: 30 * FineTune::CENTS_PER_NOTE
+            },
+            FineTune::from_note(30)
+        );
+    }
+
+    #[test]
+    fn pitch_factor_works() {
+        assert_approx_eq!(2.0, FineTune::from_note(47).pitch_factor(), 0.030);
+        assert_approx_eq!(1.0, FineTune::from_note(59).pitch_factor(), 0.015);
+        assert_approx_eq!(0.5, FineTune::from_note(71).pitch_factor(), 0.008);
+    }
+
+    #[test]
+    fn add_works() {
+        assert_eq!(
+            FineTune::from_note(54),
+            FineTune::from_note(49) + FineTune::from_note(5),
+        );
+    }
+
+    #[test]
+    fn sub_works() {
+        assert_eq!(
+            FineTune::from_note(32),
+            FineTune::from_note(40) - FineTune::from_note(8),
+        );
+    }
+}