audio working with kira. going to attempt a different audio backend

Cargo.lock

···
 ]
 
 [[package]]
+name = "atomic-arena"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73e8ed45f88ed32e6827a96b62d8fd4086d72defc754c5c6bd08470c1aaf648e"
+
+[[package]]
 name = "atomic-waker"
 version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "portable-atomic",
  "portable-atomic-util",
-]
-
-[[package]]
-name = "audionimbus-sys"
-version = "4.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb5d2e6b2a80ceca3ed697ddf6d11389a70a2186ae02e8038278469097d4ec44"
-dependencies = [
- "bindgen 0.71.1",
 ]
 
 [[package]]
···
  "approx",
  "bevy_reflect",
  "derive_more",
- "glam 0.30.9",
+ "glam",
  "itertools 0.14.0",
  "libm",
  "rand 0.9.2",
···
  "downcast-rs 2.0.2",
  "erased-serde",
  "foldhash 0.2.0",
- "glam 0.30.9",
+ "glam",
  "inventory",
  "petgraph",
  "serde",
···
 ]
 
 [[package]]
-name = "bevy_seedling"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb0d2bb3af43e45ea318865e49cf2c33e32f32a986fcaf6d7a4e73a093ce1766"
-dependencies = [
- "bevy_app",
- "bevy_asset",
- "bevy_ecs",
- "bevy_log",
- "bevy_math",
- "bevy_platform",
- "bevy_reflect",
- "bevy_seedling_macros",
- "bevy_time",
- "bevy_transform",
- "ebur128",
- "firewheel",
- "firewheel-ircam-hrtf",
- "portable-atomic",
- "rand 0.9.2",
- "smallvec",
- "symphonia",
- "symphonium",
-]
-
-[[package]]
-name = "bevy_seedling_macros"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71af121c6c880413f48ce79a217312bb951d2b07cbd3f654dc93211c12bd7c05"
-dependencies = [
- "bevy_macro_utils",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
 name = "bevy_shader"
 version = "0.17.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "bindgen"
-version = "0.71.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3"
-dependencies = [
- "bitflags 2.10.0",
- "cexpr",
- "clang-sys",
- "itertools 0.13.0",
- "log",
- "prettyplease",
- "proc-macro2",
- "quote",
- "regex",
- "rustc-hash 2.1.1",
- "shlex",
- "syn",
-]
-
-[[package]]
-name = "bindgen"
 version = "0.72.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ceec7a6067e62d6f931a2baf6f3a751f4a892595bcec1461a3c94ef9949864b6"
 dependencies = [
- "bindgen 0.72.1",
+ "bindgen",
 ]
 
 [[package]]
···
 checksum = "f27ae1dd37df86211c42e150270f82743308803d90a6f6e6651cd730d5e1732f"
 
 [[package]]
-name = "dasp_frame"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2a3937f5fe2135702897535c8d4a5553f8b116f76c1529088797f2eee7c5cd6"
-dependencies = [
- "dasp_sample",
-]
-
-[[package]]
 name = "dasp_sample"
 version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76"
 
 [[package]]
-name = "ebur128"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e227cc62d64d6fe01abbef48134b9c1f17d470cef1e7a56337ad05b1f81df7f9"
-dependencies = [
- "bitflags 1.3.2",
- "dasp_frame",
- "dasp_sample",
- "smallvec",
-]
-
-[[package]]
 name = "either"
 version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "const_panic",
  "encase_derive",
- "glam 0.30.9",
+ "glam",
  "thiserror 2.0.17",
 ]
 
···
 checksum = "af9673d8203fcb076b19dfd17e38b3d4ae9f44959416ea532ce72415a6020365"
 
 [[package]]
-name = "fast-interleave"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0a5ab837f0983c0a9210d7847931f64e3be67fcb0ab93d625f7845a0132c825"
-
-[[package]]
 name = "fastrand"
 version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "audionimbus-sys",
- "cpal 0.16.0",
- "hound",
+ "bevy",
+ "kira",
 ]
 
 [[package]]
···
 dependencies = [
  "anyhow",
  "bevy",
- "bevy_seedling",
  "cpal 0.16.0",
  "dotenvy",
+ "felix-audio",
  "felix-net",
  "tokio",
 ]
···
 checksum = "3a3076410a55c90011c298b04d0cfa770b00fa04e1e3c97d3f6c9de105a03844"
 
 [[package]]
-name = "firewheel"
-version = "0.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4a3247a4004d294962675375b2f539fb31990563261a385e7ef1353c1addd60"
-dependencies = [
- "firewheel-core",
- "firewheel-cpal",
- "firewheel-graph",
- "firewheel-nodes",
- "firewheel-pool",
- "thiserror 2.0.17",
-]
-
-[[package]]
-name = "firewheel-core"
-version = "0.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d57ae9ba24554846916e77affb2c9efea35f6d7f39ae2f56329db309f8396a9"
-dependencies = [
- "arrayvec",
- "bevy_ecs",
- "bevy_platform",
- "bevy_reflect",
- "bitflags 2.10.0",
- "firewheel-macros",
- "fixed-resample",
- "glam 0.29.3",
- "glam 0.30.9",
- "log",
- "num-traits",
- "portable-atomic",
- "ringbuf",
- "rtgc",
- "smallvec",
- "symphonium",
- "thiserror 2.0.17",
- "thunderdome",
- "wmidi",
-]
-
-[[package]]
-name = "firewheel-cpal"
-version = "0.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f561251f37171d143922c3b8e45c102f9d79fd9ce4bd6faaa62550af1c5b2b1d"
-dependencies = [
- "bevy_platform",
- "cpal 0.16.0",
- "fast-interleave",
- "firewheel-core",
- "firewheel-graph",
- "fixed-resample",
- "log",
- "ringbuf",
- "thiserror 2.0.17",
-]
-
-[[package]]
-name = "firewheel-graph"
-version = "0.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7730621467abd9aa6a945c6aa11447d5334d9427f0e51699c391e2648b8bc0c8"
-dependencies = [
- "arrayvec",
- "bevy_platform",
- "bevy_reflect",
- "firewheel-core",
- "log",
- "num-traits",
- "ringbuf",
- "smallvec",
- "thiserror 2.0.17",
- "thunderdome",
- "triple_buffer",
-]
-
-[[package]]
-name = "firewheel-ircam-hrtf"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16ef3ba4e1f227a7247ddc94f5850324010ecf7ecf59ee3af5a2c9fcd326b744"
-dependencies = [
- "bevy_ecs",
- "bevy_reflect",
- "firewheel",
- "glam 0.30.9",
- "hrtf",
-]
-
-[[package]]
-name = "firewheel-macros"
-version = "0.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34833b22730fd510e34b07df943ce4e1495bc4f1d738a959cb31c0431f938b46"
-dependencies = [
- "bevy_macro_utils",
- "proc-macro2",
- "quote",
- "syn",
- "toml_edit",
-]
-
-[[package]]
-name = "firewheel-nodes"
-version = "0.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0513d8c83c24108b8dd8e28f572d5c90a87d085ca81929adb0cff2a62eff0863"
-dependencies = [
- "bevy_ecs",
- "bevy_platform",
- "bevy_reflect",
- "firewheel-core",
- "fixed-resample",
- "num-traits",
- "smallvec",
-]
-
-[[package]]
-name = "firewheel-pool"
-version = "0.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57b3f2122f632fcaff37d9c42e3b33d050199c180d8c13161f9f808a47b009f9"
-dependencies = [
- "bevy_platform",
- "firewheel-core",
- "firewheel-graph",
- "firewheel-nodes",
- "smallvec",
- "thiserror 2.0.17",
- "thunderdome",
-]
-
-[[package]]
-name = "fixed-resample"
-version = "0.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e548b80c8a294b230847d73ae8e53d1b2d5b407a1a9ec51c9698a761c4610b1"
-dependencies = [
- "arrayvec",
- "fast-interleave",
- "ringbuf",
- "rubato 0.16.2",
-]
-
-[[package]]
 name = "fixedbitset"
 version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "glam"
-version = "0.29.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8babf46d4c1c9d92deac9f7be466f76dfc4482b6452fc5024b5e8daf6ffeb3ee"
-
-[[package]]
-name = "glam"
 version = "0.30.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bd47b05dddf0005d850e5644cae7f2b14ac3df487979dbfff3b56f20b1a6ae46"
 dependencies = [
  "bytemuck",
  "libm",
+ "mint",
  "rand 0.9.2",
  "serde_core",
 ]
···
 checksum = "29a164ceff4500f2a72b1d21beaa8aa8ad83aec2b641844c659b190cb3ea2e0b"
 dependencies = [
  "constgebra",
- "glam 0.30.9",
+ "glam",
  "tinyvec",
 ]
 
···
 checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df"
 
 [[package]]
-name = "hound"
-version = "3.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62adaabb884c94955b19907d60019f4e145d091c75345379e70d1ee696f7854f"
-
-[[package]]
-name = "hrtf"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f4de47a84fd55fa33aa5ef337016814fdc869fdad23e7898b5322fa290248e6"
-dependencies = [
- "byteorder",
- "rubato 0.14.1",
- "rustfft",
-]
-
-[[package]]
 name = "image"
 version = "0.25.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc"
+
+[[package]]
+name = "kira"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8b2ed698ad54d270ee1d8b340604201bf538dacf8bf31e378da00690b9ea20a"
+dependencies = [
+ "atomic-arena",
+ "cpal 0.16.0",
+ "glam",
+ "mint",
+ "pastey",
+ "rtrb",
+ "send_wrapper",
+ "symphonia",
+ "triple_buffer",
+]
 
 [[package]]
 name = "ktx2"
···
 ]
 
 [[package]]
+name = "mint"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e53debba6bda7a793e5f99b8dacf19e626084f525f7829104ba9898f367d85ff"
+
+[[package]]
 name = "mio"
 version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
-name = "num-complex"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
-dependencies = [
- "num-traits",
-]
-
-[[package]]
 name = "num-derive"
 version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "proc-macro2",
  "quote",
  "syn",
-]
-
-[[package]]
-name = "num-integer"
-version = "0.1.46"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
-dependencies = [
- "num-traits",
 ]
 
 [[package]]
···
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
 [[package]]
+name = "pastey"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "35fb2e5f958ec131621fdd531e9fc186ed768cbe395337403ae56c17a74c68ec"
+
+[[package]]
 name = "percent-encoding"
 version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "e8cf8e6a8aa66ce33f63993ffc4ea4271eb5b0530a9002db8455ea6050c77bfa"
 
 [[package]]
-name = "prettyplease"
-version = "0.2.37"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
-dependencies = [
- "proc-macro2",
- "syn",
-]
-
-[[package]]
-name = "primal-check"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc0d895b311e3af9902528fbb8f928688abbd95872819320517cc24ca6b2bd08"
-dependencies = [
- "num-integer",
-]
-
-[[package]]
 name = "proc-macro-crate"
 version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
-name = "realfft"
-version = "3.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f821338fddb99d089116342c46e9f1fbf3828dba077674613e734e01d6ea8677"
-dependencies = [
- "rustfft",
-]
-
-[[package]]
 name = "rectangle-pack"
 version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "19b30a45b0cd0bcca8037f3d0dc3421eaf95327a17cad11964fb8179b4fc4832"
 
 [[package]]
-name = "ringbuf"
-version = "0.4.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe47b720588c8702e34b5979cb3271a8b1842c7cb6f57408efa70c779363488c"
-dependencies = [
- "crossbeam-utils",
- "portable-atomic",
- "portable-atomic-util",
-]
-
-[[package]]
 name = "rodio"
 version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "6c20b6793b5c2fa6553b250154b78d6d0db37e72700ae35fad9387a46f487c97"
 
 [[package]]
-name = "rtgc"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ff37e188d26f62b595065458583a6a7101a52343b112c10a2b277e7a490247d"
-dependencies = [
- "bevy_platform",
-]
-
-[[package]]
-name = "rubato"
-version = "0.14.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6dd52e80cfc21894deadf554a5673002938ae4625f7a283e536f9cf7c17b0d5"
-dependencies = [
- "num-complex",
- "num-integer",
- "num-traits",
- "realfft",
-]
-
-[[package]]
-name = "rubato"
-version = "0.16.2"
+name = "rtrb"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5258099699851cfd0082aeb645feb9c084d9a5e1f1b8d5372086b989fc5e56a1"
-dependencies = [
- "num-complex",
- "num-integer",
- "num-traits",
- "realfft",
-]
+checksum = "ad8388ea1a9e0ea807e442e8263a699e7edcb320ecbcd21b4fa8ff859acce3ba"
 
 [[package]]
 name = "rustc-hash"
···
 checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
 dependencies = [
  "semver",
-]
-
-[[package]]
-name = "rustfft"
-version = "6.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21db5f9893e91f41798c88680037dba611ca6674703c1a18601b01a72c8adb89"
-dependencies = [
- "num-complex",
- "num-integer",
- "num-traits",
- "primal-check",
- "strength_reduce",
- "transpose",
 ]
 
 [[package]]
···
 checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
-name = "strength_reduce"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe895eb47f22e2ddd4dabc02bce419d2e643c8e3b585c78158b349195bc24d82"
-
-[[package]]
 name = "strict-num"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "5773a4c030a19d9bfaa090f49746ff35c75dfddfa700df7a5939d5e076a57039"
 dependencies = [
  "lazy_static",
+ "symphonia-bundle-flac",
+ "symphonia-bundle-mp3",
  "symphonia-codec-pcm",
  "symphonia-codec-vorbis",
  "symphonia-core",
···
 ]
 
 [[package]]
+name = "symphonia-bundle-flac"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c91565e180aea25d9b80a910c546802526ffd0072d0b8974e3ebe59b686c9976"
+dependencies = [
+ "log",
+ "symphonia-core",
+ "symphonia-metadata",
+ "symphonia-utils-xiph",
+]
+
+[[package]]
+name = "symphonia-bundle-mp3"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4872dd6bb56bf5eac799e3e957aa1981086c3e613b27e0ac23b176054f7c57ed"
+dependencies = [
+ "lazy_static",
+ "log",
+ "symphonia-core",
+ "symphonia-metadata",
+]
+
+[[package]]
 name = "symphonia-codec-pcm"
 version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "bytemuck",
  "lazy_static",
  "log",
- "rustfft",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
-name = "symphonium"
-version = "0.6.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94700d892b055c7c25e2fc5319b43d59434119627a08a5096cdcd0fe5345914f"
-dependencies = [
- "fast-interleave",
- "fixed-resample",
- "log",
- "symphonia",
-]
-
-[[package]]
 name = "syn"
 version = "2.0.111"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "cfg-if",
 ]
-
-[[package]]
-name = "thunderdome"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92e170f93360bf9ae6fe3c31116bbf27adb1d054cedd6bc3d7857e34f2d98d0b"
 
 [[package]]
 name = "tiny-skia"
···
  "tracing",
  "tracing-subscriber",
  "wasm-bindgen",
-]
-
-[[package]]
-name = "transpose"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ad61aed86bc3faea4300c7aee358b4c6d0c8d6ccc36524c96e4c92ccf26e77e"
-dependencies = [
- "num-integer",
- "strength_reduce",
 ]
 
 [[package]]
···
 version = "0.46.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
-
-[[package]]
-name = "wmidi"
-version = "4.0.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e55f35b40ad0178422d06e9ba845041baf2faf04627b91fde928d0f6a21c712"
 
 [[package]]
 name = "x11-dl"

audio/Cargo.toml

···
 
 [dependencies]
 anyhow = "1.0.100"
-cpal = "0.16.0"
-hound = "3.5.1"
-audionimbus-sys = { version = "4.7.0", features = ["auto-install"] }
+bevy = "0.17.3"
+kira = "0.11.0"

audio/examples/test.rs

···
-use felix_audio::{AudioThread, source::AudioSource, utils::wav};
-
-fn main(){
-  let audio = AudioThread::start();
-
-  let mut source = AudioSource::new();
-
-  let mut sample_index = 0;
-  let samples = wav::load_wav_file("/home/phaze/Projects/Projects/felix/audio/out2.wav".into());
-
-  source.on_request_data(move | output, _ | {
-    let length = output.len();
-
-    let input_stream = &samples[sample_index..(sample_index + length)];
-    sample_index += length;
-
-    for i in 0..length{ output[i] = input_stream[i] }
-  });
-
-  audio.add_source(source);
-
-  loop {}
-}

audio/src/lib.rs

···
-use std::{ptr::{null, null_mut}, sync::{Arc, Mutex, mpsc::{Sender, channel}}, thread, vec};
+use std::{f32::consts::TAU, thread, time::Duration};
 
-use audionimbus_sys::*;
-use cpal::{BufferSize, SampleRate, Stream, StreamConfig, traits::{DeviceTrait, HostTrait, StreamTrait}};
+use bevy::{app::{App, Plugin, Startup, Update}, ecs::{component::Component, system::{Commands, Query}}, math::{Quat, Vec3}, transform::components::Transform};
+use kira::{AudioManager, AudioManagerSettings, Decibels, DefaultBackend, Easing, Mapping, Tween, Value, effect::filter::FilterBuilder, listener::ListenerHandle, sound::static_sound::StaticSoundData, track::{SendTrackBuilder, SpatialTrackBuilder}};
 
-use crate::source::AudioSource;
+use crate::source::FelixAudioSource;
 
 pub mod source;
-mod voice;
-pub mod utils;
 
-const CHANNEL_COUNT: u16 = 2;
-const SAMPLE_RATE: u32 = 48_000;
-const BUFFER_SIZE: u32 = 512;
-const DISTANCE_FALLOFF: f32 = 1.0;
+fn update_listener_transform(
+  mut audio_system: Query<&mut FelixAudioComponent>,
+  listener: Query<(&FelixAudioListener, &Transform)>
+){
+  let mut audio_system = audio_system.single_mut().expect("Cannot find FelixAudioComponent, has audio system been initialised?");
+  let ( _, listener_transform ) = listener.single().expect("Cannot find FelixAudioListener.");
 
-pub type Sample = f32;
-
-enum AudioThreadCommand{
-  AddSource(AudioSource)
+  audio_system.main_listener.set_position(listener_transform.translation, Tween::default());
+  audio_system.main_listener.set_orientation(listener_transform.rotation, Tween::default());
 }
 
-pub struct AudioThread{
-  sender: Sender<AudioThreadCommand>,
-  stream: Stream
-}
+fn update_audio_sources(
+  mut audio_system: Query<&mut FelixAudioComponent>,
+  sources: Query<(&mut FelixAudioSource, &Transform)>,
+){
+  let mut audio_system = audio_system.single_mut().expect("Cannot find FelixAudioComponent, has audio system been initialised?");
 
-fn build_context() -> IPLContext{
-  let mut context: IPLContext = IPLContext::default();
-  unsafe {
-    iplContextCreate(
-      &mut IPLContextSettings {
-        version: STEAMAUDIO_VERSION,
-        logCallback: None,
-        allocateCallback: None,
-        freeCallback: None,
-        simdLevel: IPLSIMDLevel::IPL_SIMDLEVEL_AVX2,
-        flags: IPLContextFlags::IPL_CONTEXTFLAGS_FORCE_32BIT
-      },
-      &mut context
-    );
+  for ( mut source, transform ) in sources{
+    if source.needs_init(){
+      source.init(&mut audio_system);
+    } else {
+      source.update(transform);
+    }
   }
-
-  context
 }
 
-impl AudioThread{
-  pub fn start() -> Self{
-    let ( sender, recv ) = channel();
+#[derive(Component)]
+pub struct FelixAudioListener;
 
-    let host = cpal::default_host();
-    let device = host.default_output_device().expect("No output available.");
+#[derive(Component)]
+pub struct FelixAudioComponent{
+  manager: AudioManager<DefaultBackend>,
+  main_listener: ListenerHandle
+}
 
-    let info = AudioThreadInfo {
-      sample_rate: SAMPLE_RATE,
-      buffer_size: BUFFER_SIZE,
-      channel_count: CHANNEL_COUNT
-    };
+pub struct FelixAudio;
 
-    let ( request_sender, request_recv ) = channel();
-    let ( response_sender, response_recv ) = channel();
+impl Plugin for FelixAudio{
+  fn build(&self, app: &mut App) {
+    app.add_systems(Startup, move | mut commands: Commands | {
+      let mut manager = AudioManager::<DefaultBackend>::new(AudioManagerSettings::default()).unwrap();
+      let main_listener = manager.add_listener(Vec3::default(), Quat::default()).unwrap();
 
-    let stream = device.build_output_stream(
-      &(&info).into(),
-      move | output: &mut [ Sample ], _ |{
-        request_sender.send(output.len()).unwrap();
-        let dat: Vec<f32> = response_recv.recv().unwrap();
+      let handle = FelixAudioComponent { manager, main_listener };
 
-        for i in 0..output.len(){ output[i] = dat[i]; }
-      },
-      |err| println!("{err:?}"),
-      None
-    ).unwrap();
+      commands.spawn(handle);
+    });
 
-    thread::spawn(move || {
-      // Audio thread.
-      let mut audio_settings: IPLAudioSettings = (&info).into();
+    app.add_systems(Update, update_listener_transform);
+    app.add_systems(Update, update_audio_sources);
+  }
+}
 
-      let mut sources: Vec<AudioSource> = vec![];
-      let context = build_context();
+pub fn main(){
+  let mut manager = AudioManager::<DefaultBackend>::new(AudioManagerSettings::default()).unwrap();
 
-      let mut hrtf: IPLHRTF = IPLHRTF::default();
-      unsafe {
-        iplHRTFCreate(
-          &mut *context,
-          &mut audio_settings,
-          &mut IPLHRTFSettings {
-            type_: IPLHRTFType::IPL_HRTFTYPE_DEFAULT,
-            sofaFileName: null(),
-            sofaData: null(),
-            sofaDataSize: 0,
-            volume: 1.0,
-            normType: IPLHRTFNormType::IPL_HRTFNORMTYPE_RMS
-          },
-          &mut hrtf
-        );
-      }
+  let listener = manager.add_listener(
+    [ 0.0, 0.0, 0.0 ],
+    Quat::default()
+  ).unwrap();
 
-      let mut binaural_effect: IPLBinauralEffect = IPLBinauralEffect::default();
-      unsafe {
-        iplBinauralEffectCreate(
-          &mut *context,
-          &mut audio_settings,
-          &mut IPLBinauralEffectSettings { hrtf: &mut *hrtf },
-          &mut binaural_effect
-        );
-      }
+  let send = manager.add_send_track(
+    SendTrackBuilder::new()
+  ).unwrap();
 
-      while let Ok(length) = request_recv.recv(){
-        let mut output = vec![0.0; length];
-
-        if let Ok(ev) = recv.try_recv(){
-          match ev{
-            AudioThreadCommand::AddSource(mut source) => {
-              source.setup(&info);
-              sources.push(source);
-            }
-          }
-        }
-
-        output.fill(0.0);
-        for source in &mut sources{
-          let input = source.render(output.len(), &info);
-
-          let direction: ( f32, f32, f32 ) = ( 1.0, 0.2, 1.0 );
-
-          let dist = (
-            direction.0 * direction.0 +
-            direction.1 * direction.1 +
-            direction.2 * direction.2
-          ).sqrt();
-
-          let dist_falloff = (1.0 / (1.0 + DISTANCE_FALLOFF * ( dist - 1.0 ) )).clamp(0.0, 1.0);
-
-          if dist_falloff < 0.05{ return }; // If too far away, skip audio processing.
-
-          let mut input_buffer = IPLAudioBuffer {
-            numChannels: 1,
-            numSamples: input.len() as i32,
-            data: input.as_ptr() as *mut *mut Sample // NOTE: Technically this buffer is interleaved, but it *should* be mono, so we don't need to deinterleave it.
-          };
-
-          let staging_container = vec![0.0; input.len() * 2 as usize];
-          let mut staging_buffer = IPLAudioBuffer {
-            numChannels: info.channel_count as i32,
-            numSamples: input.len() as i32,
-            data: staging_container.as_slice().as_ptr() as *mut *mut Sample
-          };
-
-          let mut binaural_effect_params = IPLBinauralEffectParams {
-            direction: IPLVector3 { x: direction.0, y: direction.1, z: direction.2 },
-            interpolation: IPLHRTFInterpolation::IPL_HRTFINTERPOLATION_NEAREST,
-            spatialBlend: 1.0,
-            hrtf: hrtf,
-            peakDelays: null_mut()
-          };
-
-          unsafe {
-            iplBinauralEffectApply(
-              binaural_effect,
-              &mut binaural_effect_params,
-              &mut input_buffer,
-              &mut staging_buffer
-            );
-          }
-
-          for i in 0..staging_container.len(){
-            output[i] = staging_container[i] * dist_falloff;
-          }
-
-          unsafe { iplAudioBufferFree(&mut *context, &mut staging_buffer); }
-        }
-
-        response_sender.send(output).unwrap();
-      }
-    });
+  let radius = 50.0;
+  let mut angle: f32 = 0.0;
 
-    stream.play().unwrap();
-
-    Self {
-      sender,
-      stream
-    }
-  }
+  let mut spatial_track = manager.add_spatial_sub_track(
+    &listener,
+    [
+      angle.sin() * radius,
+      0.0,
+      angle.cos() * radius
+    ],
+    SpatialTrackBuilder::new()
+      .with_effect(
+        FilterBuilder::new().cutoff(Value::FromListenerDistance(Mapping {
+          input_range: ( 0.0, 20.0 ),
+          output_range: ( 18000.0, 2000.0 ),
+          easing: Easing::Linear
+        }))
+      ).with_send(&send, Value::FromListenerDistance(Mapping {
+        input_range: ( 0.0, 20.0 ),
+        output_range: ( Decibels(24.0), Decibels(-60.0) ),
+        easing: Easing::Linear
+      }))
+  ).unwrap();
 
-  pub fn add_source( &self, source: AudioSource ){
-    self.sender.send(AudioThreadCommand::AddSource(source)).unwrap();
-  }
-}
+  let sound_data = StaticSoundData::from_file("out.wav").unwrap();
+  spatial_track.play(sound_data).unwrap();
 
-pub struct AudioThreadInfo{
-  pub sample_rate: u32,
-  pub buffer_size: u32,
-  pub channel_count: u16
-}
+  loop {
+    thread::sleep(Duration::from_millis(50));
 
-impl Into<IPLAudioSettings> for &AudioThreadInfo{
-  fn into(self) -> IPLAudioSettings {
-    IPLAudioSettings {
-      samplingRate: self.sample_rate as i32,
-      frameSize: self.buffer_size as i32
-    }
-  }
-}
+    angle += TAU * 0.01;
+    dbg!(angle);
 
-impl Into<StreamConfig> for &AudioThreadInfo{
-  fn into(self) -> StreamConfig {
-    StreamConfig {
-      channels: self.channel_count,
-      sample_rate: SampleRate(self.sample_rate),
-      buffer_size: BufferSize::Fixed(self.buffer_size)
-    }
+    spatial_track.set_position(
+      [
+        angle.sin() * radius,
+        0.0,
+        angle.cos() * radius
+      ],
+      Tween::default()
+    );
   }
 }

audio/src/source.rs

···
-use std::ptr::{null, null_mut};
-
-use anyhow::bail;
-use audionimbus_sys::*;
+use bevy::{ecs::component::Component, transform::components::Transform};
 
-use crate::{AudioThreadInfo, DISTANCE_FALLOFF, Sample};
+use crate::FelixAudioComponent;
 
-pub struct AudioSource{
-  saturate_cb: Option<Box<dyn FnMut(&mut [ Sample ], &AudioThreadInfo) + Send>>,
+pub mod static_source;
 
-  buffer: Vec<Sample>
+#[derive(Component)]
+pub struct FelixAudioSource{
+  inner: Box<dyn AudioSource + Send + Sync + 'static>
 }
 
-unsafe impl Send for AudioSource {}
-
-impl AudioSource{
-  pub fn new() -> Self{
-    Self {
-      saturate_cb: None,
-
-      buffer: Vec::new()
-    }
-  }
-
-  pub fn on_request_data<T>( &mut self, saturate_cb: T )
-  where
-    T: FnMut(&mut [ Sample ], &AudioThreadInfo) + Send + 'static
-  {
-    self.saturate_cb = Some(Box::new(saturate_cb));
+impl FelixAudioSource{
+  pub fn init( &mut self, audio_system: &mut FelixAudioComponent ){
+    self.inner.init(audio_system);
   }
 
-  pub fn handle( &self ) -> AudioSourceHandle{
-    AudioSourceHandle {  }
+  pub fn needs_init( &self ) -> bool{
+    self.inner.needs_init()
   }
 
-  // Internal stuff, called by audio thread.
-  pub fn setup( &mut self, audio_settings: &AudioThreadInfo ){
-    self.buffer = vec![0.0; audio_settings.buffer_size as usize];
+  pub fn update( &mut self, transform: &Transform ){
+    self.inner.update(transform);
   }
+}
 
-  pub fn render( &mut self, length: usize, info: &AudioThreadInfo ) -> &mut [ Sample ]{
-    if let Some(saturate_cb) = &mut self.saturate_cb{
-      saturate_cb(&mut self.buffer[0..length], &info);
-      &mut self.buffer[0..length]
-    } else{
-      &mut self.buffer[0..length]
+impl<T> From<T> for FelixAudioSource
+where
+  T: AudioSource + Send + Sync + 'static
+{
+  fn from(value: T) -> Self {
+    Self {
+      inner: Box::new(value)
     }
   }
 }
 
-pub struct AudioSourceHandle{
-
+pub trait AudioSource{
+  fn init( &mut self, audio_system: &mut FelixAudioComponent );
+  fn needs_init( &self ) -> bool;
+  fn update( &mut self, transform: &Transform );
 }

audio/src/source/static_source.rs

···
+use std::{sync::{Arc, Mutex}, thread};
+
+use bevy::transform::components::Transform;
+use kira::{Decibels, Easing, Mapping, Mix, Tween, Value, effect::{filter::FilterBuilder, reverb::ReverbBuilder}, sound::static_sound::StaticSoundData, track::{SendTrackBuilder, SendTrackHandle, SpatialTrackBuilder, SpatialTrackHandle}};
+
+use crate::{FelixAudioComponent, source::AudioSource};
+
+pub struct StaticAudioSource{
+  loaded_sound_data: Arc<Mutex<Option<StaticSoundData>>>,
+  send_track: Option<SendTrackHandle>,
+  spatial_track: Option<SpatialTrackHandle>
+}
+
+impl StaticAudioSource{
+  pub fn new( path: &'static str ) -> Self{
+    let data = Arc::new(Mutex::new(None));
+    let data_1 = data.clone();
+
+    thread::spawn(move || {
+      let sound_data = StaticSoundData::from_file(&path).unwrap();
+      let mut data_1 = data_1.lock().unwrap();
+
+      *data_1 = Some(sound_data);
+      println!("Loaded: {}", path);
+    });
+
+    Self {
+      loaded_sound_data: data,
+
+      send_track: None,
+      spatial_track: None
+    }
+  }
+}
+
+impl AudioSource for StaticAudioSource{
+  fn init( &mut self, audio_system: &mut FelixAudioComponent ) {
+    if let Ok(mut lock) = self.loaded_sound_data.try_lock(){
+      if lock.is_none(){ return }
+      let sound_data = lock.take().unwrap();
+
+      let send_track = audio_system.manager.add_send_track(SendTrackBuilder::new()).unwrap();
+
+      let mut spatial_track = audio_system.manager.add_spatial_sub_track(
+        &audio_system.main_listener,
+        [
+          0.0,
+          0.0,
+          0.0
+        ],
+        SpatialTrackBuilder::new()
+          .with_effect(FilterBuilder::new().cutoff(Value::FromListenerDistance(Mapping {
+            input_range: ( 0.0, 20.0 ),
+            output_range: ( 18000.0, 2000.0 ),
+            easing: Easing::Linear
+          })))
+          .with_effect(ReverbBuilder::new().mix(Value::FromListenerDistance(Mapping {
+            input_range: ( 0.0, 100.0 ),
+            output_range: ( Mix::DRY, Mix::WET ),
+            easing: Easing::Linear
+          })))
+          .with_send(&send_track, Value::FromListenerDistance(Mapping {
+            input_range: ( 0.0, 1.0 ),
+            output_range: ( Decibels(12.0), Decibels(-100.0) ),
+            easing: Easing::Linear
+          }))
+      ).unwrap();
+
+      spatial_track.play(sound_data.clone()).unwrap();
+
+      self.send_track = Some(send_track);
+      self.spatial_track = Some(spatial_track);
+    }
+  }
+
+  fn needs_init( &self ) -> bool {
+    self.spatial_track.is_none()
+  }
+
+  fn update( &mut self, transform: &Transform ) {
+    let track = self.spatial_track.as_mut().unwrap();
+    track.set_position(transform.translation, Tween::default());
+  }
+}

audio/src/utils/mod.rs

···
-pub mod wav;

audio/src/utils/wav.rs

···
-pub fn load_wav_file( path: String ) -> Vec<f32>{
-  let mut reader = hound::WavReader::open(path).unwrap();
-  let spec = reader.spec();
-  dbg!(&spec);
-
-  let mut samples = vec![0.0; (reader.len() / spec.channels as u32) as usize];
-  let original_samples: Vec<_> = reader.samples::<i16>().map(|x| x.unwrap() as f32 / i16::MAX as f32).collect();
-
-  for i in 0..samples.len(){
-    let j = i * spec.channels as usize;
-    samples[i] = original_samples[j];
-  }
-
-  samples
-}

audio/src/voice/mod.rs

···
-use cpal::{BufferSize, SampleRate, SizedSample, Stream, StreamConfig, traits::{DeviceTrait, HostTrait}};
-
-// Credits to: https://github.com/TapGhoul/vban_transceiver/blob/main/src/main.rs#L125
-// (thanks tap)
-
-const SAMPLE_RATE: SampleRate = SampleRate(44_100);
-const BUFFER_SIZE: BufferSize = BufferSize::Fixed(512);
-
-pub fn open_mic<T, K>( mut cb: T ) -> anyhow::Result<Stream>
-where
-  T: FnMut(&[K]) + Send + 'static,
-  K: SizedSample
-{
-  let host = cpal::default_host();
-  let mic = host.default_input_device().unwrap();
-
-  let stream = mic.build_input_stream(
-    &StreamConfig {
-      channels: 1,
-      buffer_size: BUFFER_SIZE,
-      sample_rate: SAMPLE_RATE
-    },
-    move | data, _ | cb(data),
-    | err | panic!("{err}"),
-    None
-  ).unwrap();
-
-  Ok(stream)
-}
-
-pub fn open_output<T, K>( mut cb: T ) -> anyhow::Result<Stream>
-where
-  T: FnMut(&mut [K]) + Send + 'static,
-  K: SizedSample
-{
-  let host = cpal::default_host();
-  let output = host.default_output_device().unwrap();
-
-  let stream = output.build_output_stream(
-    &StreamConfig {
-      channels: 1,
-      sample_rate: SAMPLE_RATE,
-      buffer_size: BUFFER_SIZE
-    },
-    move | data, _ | cb(data),
-    | err | panic!("{err}"),
-    None
-  ).unwrap();
-
-  Ok(stream)
-}

client/Cargo.toml

···
 [dependencies]
 anyhow = "1.0.100"
 bevy = "0.17.3"
-bevy_seedling = "0.6.1"
 cpal = "0.16.0"
 dotenvy = "0.15.7"
 felix-net = { path = '../net' }
+felix-audio = { path = '../audio' }
 tokio = { version = "1.48.0", features = ["full"] }

client/src/components/network_interface.rs

···
 use std::collections::HashMap;
 
 use bevy::prelude::*;
-use bevy_seedling::prelude::StreamWriterNode;
 use felix_net::{packet::PacketTypes, packets::update_server_position::UpdateServerPositions};
 
 use crate::{debug_camera::DebugCamera, net::{NetClientCommand, connection::Connection}, remote_player::RemotePlayer};

client/src/main.rs

···
 use bevy::{DefaultPlugins, app::{App, FixedUpdate, Startup, Update}, ecs::system::Commands};
-use bevy_seedling::prelude::*;
+use felix_audio::FelixAudio;
 
 use crate::{components::{debug_camera, network_interface, remote_player}, setup::setup};
 
···
   App::new()
     .add_plugins((
       DefaultPlugins,
-      SeedlingPlugin::default()
+      FelixAudio
     ))
     .add_systems(Startup, setup)
     .add_systems(Startup, move | mut commands: Commands |{

client/src/setup.rs

···
 use bevy::prelude::*;
+use felix_audio::{FelixAudioListener, source::{FelixAudioSource, static_source::StaticAudioSource}};
 
 use crate::debug_camera;
 
···
   commands.spawn((
     Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
     MeshMaterial3d(materials.add(Color::WHITE)),
-    Transform::from_xyz(5.0, 0.0, 0.0)
+    Transform::from_xyz(5.0, 0.0, 0.0),
+    FelixAudioSource::from(StaticAudioSource::new("out.wav"))
   ));
 
   commands.spawn((
···
     debug_camera::DebugCamera::default(),
     Camera3d::default(),
     Transform::from_xyz(0.0, 0.0, 0.0).looking_at(Vec3::ZERO, Vec3::Y),
+    FelixAudioListener
   ));
 }