some audio fixes / start on unity asset bundle loading

.gitignore

···
 target/
-.env
+.env
+*.assetbundle

Cargo.lock

···
 ]
 
 [[package]]
+name = "alloc-no-stdlib"
+version = "2.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
+
+[[package]]
+name = "alloc-stdlib"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece"
+dependencies = [
+ "alloc-no-stdlib",
+]
+
+[[package]]
 name = "alsa"
 version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "num-traits",
 ]
+
+[[package]]
+name = "array-init"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d62b7694a562cdf5a74227903507c56ab2cc8bdd1f781ed5cb4cf9c9f810bfc"
 
 [[package]]
 name = "arrayref"
···
 ]
 
 [[package]]
+name = "binrw"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81419ff39e6ed10a92a7f125290859776ced35d9a08a665ae40b23e7ca702f30"
+dependencies = [
+ "array-init",
+ "binrw_derive",
+ "bytemuck",
+]
+
+[[package]]
+name = "binrw_derive"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "376404e55ec40d0d6f8b4b7df3f87b87954bd987f0cf9a7207ea3b6ea5c9add4"
+dependencies = [
+ "either",
+ "owo-colors",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
 name = "bit-set"
 version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "brotli"
+version = "3.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d640d25bc63c50fb1f0b545ffd80207d2e10a4c965530809b40ba3386825c391"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+ "brotli-decompressor",
+]
+
+[[package]]
+name = "brotli-decompressor"
+version = "2.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e2e4afe60d7dd600fdd3de8d0f08c2b7ec039712e3b6137ff98b7004e82de4f"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+]
+
+[[package]]
 name = "bumpalo"
 version = "3.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "crc"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5eb8a2a1cd12ab0d987a5d5e825195d372001a4094a0376319d5a0ad71c1ba0d"
+dependencies = [
+ "crc-catalog",
+]
+
+[[package]]
+name = "crc-catalog"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"
+
+[[package]]
 name = "crc32fast"
 version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "cpal 0.16.0",
  "dotenvy",
  "felix-audio",
+ "felix-loader",
  "felix-net",
  "openxr",
  "tokio",
 ]
 
 [[package]]
+name = "felix-loader"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "bevy",
+ "unity-asset",
+ "unity-asset-binary",
+ "unity-asset-decode",
+]
+
+[[package]]
 name = "felix-net"
 version = "0.1.0"
 dependencies = [
···
 checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
+name = "lz4_flex"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab6473172471198271ff72e9379150e9dfd70d8e533e0752a27e515b48dd375e"
+dependencies = [
+ "twox-hash",
+]
+
+[[package]]
+name = "lzma-rs"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "297e814c836ae64db86b36cf2a557ba54368d03f6afcd7d947c266692f71115e"
+dependencies = [
+ "byteorder",
+ "crc",
+]
+
+[[package]]
 name = "mach2"
 version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "num_cpus"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
 name = "num_enum"
 version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "ttf-parser 0.25.1",
 ]
+
+[[package]]
+name = "owo-colors"
+version = "4.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c6901729fa79e91a0913333229e9ca5dc725089d1c363b2f4b4760709dc4a52"
 
 [[package]]
 name = "parking"
···
 ]
 
 [[package]]
+name = "serde_bytes"
+version = "0.11.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5d440709e79d88e51ac01c4b72fc6cb7314017bb7da9eeff678aa94c10e3ea8"
+dependencies = [
+ "serde",
+ "serde_core",
+]
+
+[[package]]
 name = "serde_core"
 version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "serde_yaml"
+version = "0.9.34+deprecated"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
+dependencies = [
+ "indexmap",
+ "itoa",
+ "ryu",
+ "serde",
+ "unsafe-libyaml",
+]
+
+[[package]]
 name = "sharded-slab"
 version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "unity-asset"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6705b95fda449527055ff77fe5cff49f774dde7335ed92bc3d048fc74066ebaf"
+dependencies = [
+ "unity-asset-binary",
+ "unity-asset-core",
+ "unity-asset-yaml",
+]
+
+[[package]]
+name = "unity-asset-binary"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d739d1414c1732be1035417f83b1e60f234c7d5eb8abda0ee70d178a58137cb7"
+dependencies = [
+ "binrw",
+ "brotli",
+ "byteorder",
+ "flate2",
+ "indexmap",
+ "lz4_flex",
+ "lzma-rs",
+ "memmap2",
+ "num_cpus",
+ "once_cell",
+ "regex",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.17",
+ "unity-asset-core",
+]
+
+[[package]]
+name = "unity-asset-core"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12903fd47e122b5e7e335fc9cb5540bb35ab0ffe5bb57a7741a8c7be8d361361"
+dependencies = [
+ "indexmap",
+ "lazy_static",
+ "serde",
+ "serde_bytes",
+ "thiserror 2.0.17",
+]
+
+[[package]]
+name = "unity-asset-decode"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ea6e630cdefde54a88ca4fbae54cf3d3e5ba527fac96b085562da3b3834b77b"
+dependencies = [
+ "indexmap",
+ "serde",
+ "unity-asset-binary",
+ "unity-asset-core",
+]
+
+[[package]]
+name = "unity-asset-yaml"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b991e340c27b1578e657defee9f57de867d853b8f40448fb079d0ee3a5ebc77e"
+dependencies = [
+ "indexmap",
+ "serde",
+ "serde_yaml",
+ "thiserror 2.0.17",
+ "unity-asset-core",
+]
+
+[[package]]
+name = "unsafe-libyaml"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
 
 [[package]]
 name = "uuid"

Cargo.toml

···
 [workspace]
 resolver = "3"
-members = [ "audio", "client", "net", "server" ]
+members = [ "audio", "client", "loader", "net", "server" ]
+
+[profile.dev.package."*"]
+opt-level = 3

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 kira::{Decibels, Easing, Mapping, Tween, Value, effect::{filter::FilterBuilder}, sound::static_sound::StaticSoundData, track::{SendTrackBuilder, SendTrackHandle, SpatialTrackBuilder, SpatialTrackHandle}};
 
 use crate::{FelixAudioComponent, source::AudioSource};
 
···
           .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 {

audio/src/source/stream_source.rs

···
 use bevy::transform::components::Transform;
-use kira::{Decibels, Easing, Mapping, Mix, Tween, Value, effect::{filter::FilterBuilder, reverb::ReverbBuilder}, track::{SendTrackBuilder, SendTrackHandle, SpatialTrackBuilder, SpatialTrackHandle}};
+use kira::{Decibels, Easing, Mapping, Tween, Value, effect::{filter::FilterBuilder}, track::{SendTrackBuilder, SendTrackHandle, SpatialTrackBuilder, SpatialTrackHandle}};
 
 use crate::{FelixAudioComponent, source::{AudioSource, stream_source::sound_data::StreamAudioSourceSoundData}};
 
···
         .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 {

audio/src/voice/decoder.rs

···
 
         let mut total = 0.0;
         for sample in buffer{ total += sample.powi(2) }
-        *set_rms.write().unwrap() = ( total / buffer.len() as f32 ).sqrt();
+        *set_rms.write().unwrap() = 20.0 * ( total / buffer.len() as f32 ).sqrt().log10();
 
         let mut voice = queue.lock().unwrap();
         for sample in buffer{ voice.push_back(sample); }

audio/src/voice/microphone.rs

···
-use std::{env, net::{ToSocketAddrs, UdpSocket}, sync::{Arc, Mutex, RwLock}};
+use std::{env, net::{SocketAddr, UdpSocket}, sync::{Arc, Mutex, RwLock}};
 
 use bevy::ecs::component::Component;
 use cpal::{BufferSize, SampleRate, Stream, StreamConfig, traits::{DeviceTrait, HostTrait, StreamTrait}};
···
 #[derive(Component)]
 pub struct VoiceChatMicrophone{
   stream: Option<Stream>,
-  udp: Option<UdpSocket>,
+  addr: SocketAddr,
+  udp: UdpSocket,
   muted: Arc<Mutex<bool>>,
-  last_rms: Arc<RwLock<isize>>
+  last_rms: Arc<RwLock<f32>>,
+  gate_level: Arc<RwLock<f32>>
 }
 
 impl VoiceChatMicrophone{
-  pub fn new( socket: UdpSocket ) -> Self{
+  pub fn new( addr: SocketAddr, socket: UdpSocket ) -> Self{
     Self {
       stream: None,
-      udp: Some(socket),
+      addr,
+      udp: socket,
       muted: Arc::new(Mutex::new(false)), // TODO: Default to muted
-      last_rms: Arc::new(RwLock::new(0))
+      last_rms: Arc::new(RwLock::new(0.0)),
+      gate_level: Arc::new(RwLock::new(-65.0))
     }
   }
 
···
     let mut buffer = [0; MONO_20MS];
 
     let muted = self.muted.clone();
-    let udp = self.udp.take().unwrap();
 
-    let addr = env::var("HOST")?.to_socket_addrs()?.nth(0).unwrap();
+    let udp = self.udp.try_clone().unwrap();
+    let addr = self.addr.clone();
 
     for conf in mic.supported_input_configs().unwrap(){
       println!("{} {:?} {} {:?}", conf.channels(), conf.buffer_size(), conf.sample_format(), conf.with_max_sample_rate());
     }
 
     let set_rms = self.last_rms.clone();
+    let gate_level = self.gate_level.clone();
 
     let stream = mic.build_input_stream(
       &StreamConfig {
···
           buffer_indx = 0;
         } else{
           for i in 0..data.len(){
-            if i % 2 == 0{ continue; }
+            if i % 2 == 1{ continue; }
 
             buffer[buffer_indx] = data[i];
             buffer_indx += 1;
···
             if buffer_indx >= MONO_20MS{
               buffer_indx = 0;
 
-              let mut total = 0;
-              for sample in buffer{ total += (sample as isize).pow(2) }
-              *set_rms.write().unwrap() = ( total / buffer.len() as isize ).isqrt();
+              let mut total = 0.0;
+              for sample in buffer{ total += (sample as f32).powi(2) }
 
-              let len = encoder.encode(&buffer, &mut output).unwrap();
-              let buf_to_send = output[0..len].to_vec();
+              let rms = 20.0 * ( ( total / buffer.len() as f32 ).sqrt() / i16::MAX as f32 ).log10();
+              *set_rms.write().unwrap() = rms;
 
-              let packet = PlayerVoicePacket {
-                id: "".into(), // NOTE: I know this kinda seems stupid but it's easier for me to get the player id on the server so imma just make the server fill this in.
-                packet: buf_to_send
-              };
+              if rms > *gate_level.read().unwrap(){
+                let len = encoder.encode(&buffer, &mut output).unwrap();
+                let buf_to_send = output[0..len].to_vec();
 
-              let packet: Vec<u8> = packet.to_buf().into();
-              udp.send_to(&packet, addr).unwrap();
+                let packet = PlayerVoicePacket {
+                  id: "".into(), // NOTE: I know this kinda seems stupid but it's easier for me to get the player id on the server so imma just make the server fill this in.
+                  packet: buf_to_send
+                };
+
+                let packet: Vec<u8> = packet.to_buf().into();
+                udp.send_to(&packet, addr).unwrap();
+              }
             }
           }
         }
···
     Ok(())
   }
 
-  pub fn get_rms_of_last_packet( &self ) -> f32{
-    *self.last_rms.read().unwrap() as f32 / i16::MAX as f32
+  pub fn get_rms_of_last_packet( &self ) -> ( f32, bool ){
+    let rms = *self.last_rms.read().unwrap();
+    let gate = *self.gate_level.read().unwrap();
+
+    ( rms, rms > gate )
   }
 }

audio/src/voice/mod.rs

···
-use std::net::UdpSocket;
+use std::net::{SocketAddr, UdpSocket};
 
 use crate::voice::microphone::VoiceChatMicrophone;
 
 pub mod decoder;
 pub mod microphone;
 
-pub fn init_microphone( socket: UdpSocket ) -> anyhow::Result<VoiceChatMicrophone>{
-  let mut handle = VoiceChatMicrophone::new(socket);
+pub fn init_microphone( addr: SocketAddr, socket: UdpSocket ) -> anyhow::Result<VoiceChatMicrophone>{
+  let mut handle = VoiceChatMicrophone::new(addr, socket);
   handle.start_stream()?;
 
   Ok(handle)

client/Cargo.toml

···
 dotenvy = "0.15.7"
 felix-net = { path = '../net' }
 felix-audio = { path = '../audio' }
+felix-loader = { path = '../loader' }
 tokio = { version = "1.48.0", features = ["full"] }
 bevy_mod_openxr = "0.4.0"
 openxr = "0.19.0"

client/src/components/debug_camera.rs

···
 
   let mut remote_rms = "".to_owned();
   for id in net_manager.get_remote_player_voice_ids(){
-    remote_rms += format!("{}: {:.4}\n", id, net_manager.get_remote_player_voice_rms(&id)).as_str();
+    remote_rms += format!(
+      "{}: {:.4}db\n",
+      id,
+      net_manager.get_remote_player_voice_rms(&id)
+    ).as_str();
   }
 
-  let rms = if let Ok(mic) = voice.single(){
+  let ( rms, mic_open ) = if let Ok(mic) = voice.single(){
     mic.get_rms_of_last_packet()
   } else{
-    -1.0
+    ( -1.0, false )
   };
 
   let ( mut text, _ ) = debug_text.single_mut().unwrap();
   text.0 = format!(
-"Microphone RMS: {:.4}
-{}Position: {:.2} {:.2} {:.2}
-Rotation: {:.2} {:.2} {:.2} {:.2}
+"Microphone RMS: {:.4}db Open: {}
+{}Position: X: {:.2} Y: {:.2} Z: {:.2}
+Rotation: X: {:.2} Y: {:.2} Z: {:.2} W: {:.2}
 XR State: {:#?}",
     rms,
+    mic_open,
 
     remote_rms,
 

client/src/main.rs

···
+use std::{env, net::ToSocketAddrs};
+
 use bevy::{app::{App, FixedUpdate, Startup, Update}, ecs::system::Commands, prelude::*, render::pipelined_rendering::PipelinedRenderingPlugin};
 use bevy_mod_openxr::{add_xr_plugins, resources::OxrSessionConfig};
 use bevy_mod_xr::session::{XrSessionCreated, XrSessionPlugin};
···
     .add_systems(XrSessionCreated, || { println!("[INFO] Started VR") })
     .add_systems(Startup, setup)
     .add_systems(Startup, move | mut commands: Commands |{
-      let ( comp, voice ) = net::handle_net().expect("Network Module Failed");
+      let addr = env::var("HOST").unwrap().to_socket_addrs().unwrap().nth(0).unwrap();
+
+      let ( comp, voice ) = net::handle_net(addr.clone()).expect("Network Module Failed");
       commands.spawn(comp);
 
-      match voice::init_microphone(voice){
+      match voice::init_microphone(addr, voice){
         Ok(voice) => { commands.spawn(voice); },
         Err(err) => println!("[WARN] Failed to start microphone: {}", err)
       }

client/src/net/connection.rs

···
       voice_queues: Arc::new(RwLock::new(HashMap::new())),
       id: "".to_owned(),
 
-      killed_signal:  killed_signal_send
+      killed_signal: killed_signal_send
     };
 
     conn.start_listener_thread(event_sender, killed_signal).unwrap();

client/src/net/mod.rs

···
-use std::{env, net::{TcpStream, ToSocketAddrs, UdpSocket}};
+use std::net::{SocketAddr, TcpStream, UdpSocket};
 
 use bevy::prelude::*;
 use felix_net::packet::PacketTypes;
···
   RecvPacket(PacketTypes)
 }
 
-pub fn handle_net() -> anyhow::Result<( Connection, UdpSocket )>{
-  let addr = env::var("HOST")?.to_socket_addrs()?.nth(0).unwrap();
-
+pub fn handle_net( addr: SocketAddr ) -> anyhow::Result<( Connection, UdpSocket )>{
   let tcp = TcpStream::connect(addr)?;
   let udp = UdpSocket::bind("0.0.0.0:0")?;
 

client/src/setup.rs

···
 
   // TODO: UI and Menus
 
-  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),
-  ));
+  // 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),
+  // ));
 
-  commands.spawn((
-    Mesh3d(meshes.add(Cuboid::new(0.5, 0.5, 0.5))),
-    MeshMaterial3d(materials.add(Color::WHITE)),
-    Transform::from_xyz(-5.0, 0.0, 0.0)
-  ));
+  // commands.spawn((
+  //   Mesh3d(meshes.add(Cuboid::new(0.5, 0.5, 0.5))),
+  //   MeshMaterial3d(materials.add(Color::WHITE)),
+  //   Transform::from_xyz(-5.0, 0.0, 0.0)
+  // ));
 
-  commands.spawn((
-    Mesh3d(meshes.add(Cuboid::new(0.5, 0.5, 0.5))),
-    MeshMaterial3d(materials.add(Color::WHITE)),
-    Transform::from_xyz(0.0, 0.0, 5.0)
-  ));
+  // commands.spawn((
+  //   Mesh3d(meshes.add(Cuboid::new(0.5, 0.5, 0.5))),
+  //   MeshMaterial3d(materials.add(Color::WHITE)),
+  //   Transform::from_xyz(0.0, 0.0, 5.0)
+  // ));
 
-  commands.spawn((
-    Mesh3d(meshes.add(Cuboid::new(0.5, 0.5, 0.5))),
-    MeshMaterial3d(materials.add(Color::WHITE)),
-    Transform::from_xyz(0.0, 0.0, -5.0)
-  ));
+  // commands.spawn((
+  //   Mesh3d(meshes.add(Cuboid::new(0.5, 0.5, 0.5))),
+  //   MeshMaterial3d(materials.add(Color::WHITE)),
+  //   Transform::from_xyz(0.0, 0.0, -5.0)
+  // ));
 
   commands.spawn((
     DebugCamera::default(), // TODO: Build a proper player controller
···
     Transform::from_xyz(0.0, 0.0, 0.0).looking_at(Vec3::ZERO, Vec3::Y),
     FelixAudioListener
   ));
+
+  let gos = felix_loader::load("bundle").unwrap();
+  for go in gos{
+    if let Some(mesh) = go.mesh_filter{
+      commands.spawn((
+        Mesh3d(meshes.add(mesh)),
+        MeshMaterial3d(materials.add(Color::WHITE)),
+        go.transform
+      ));
+    }
+  }
 }

loader/Cargo.toml

···
+[package]
+name = "felix-loader"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+anyhow = "1.0.100"
+unity-asset = "0.2.0"
+unity-asset-binary = "0.2.0"
+unity-asset-decode = { version = "0.2.0", features = [ "mesh" ] }
+bevy = "0.17.3"

loader/examples/test.rs

···
+fn main(){
+  felix_loader::load("bundle").unwrap();
+}

loader/src/lib.rs

···
+use crate::unity::GameObject;
+
+mod unity;
+mod util;
+
+pub fn load( path: &'static str ) -> anyhow::Result<Vec<GameObject>>{
+  unity::load(path)
+}

loader/src/unity/component/mesh_renderer.rs

···
+use unity_asset_binary::object::UnityObject;
+
+use crate::unity::component::Component;
+
+#[derive(Debug)]
+pub struct MeshRenderer{
+
+}
+
+impl Component for MeshRenderer{
+
+}
+
+impl From<UnityObject> for MeshRenderer{
+  fn from(value: UnityObject) -> Self {
+    // dbg!(value.property_names());
+
+    Self {
+
+    }
+  }
+}

loader/src/unity/component/mod.rs

···
+pub mod transform;
+pub mod mesh_renderer;
+
+pub trait Component{
+
+}

loader/src/unity/component/transform.rs

···
+use bevy::transform::components::Transform;
+use unity_asset_binary::object::UnityObject;
+
+use crate::util::unity_value::{unity_value_to_quat, unity_value_to_vec3};
+
+pub fn into_bevy_transform(value: UnityObject) -> Transform {
+  let position = value.get("m_LocalPosition").unwrap();
+  let rotation = value.get("m_LocalRotation").unwrap();
+  let scale = value.get("m_LocalScale").unwrap();
+
+  Transform {
+    translation: unity_value_to_vec3(position),
+    rotation: unity_value_to_quat(rotation),
+    scale: unity_value_to_vec3(scale)
+  }
+}

loader/src/unity/mod.rs

···
+use anyhow::bail;
+use bevy::{prelude::*, transform::components::Transform};
+use unity_asset::environment::{Environment, EnvironmentObjectRef};
+use unity_asset_binary::unity_version::UnityVersion;
+use unity_asset_decode::mesh::MeshParser;
+
+use crate::{unity::component::{Component, mesh_renderer::MeshRenderer, transform::into_bevy_transform}, util};
+
+mod component;
+
+#[derive(Debug)]
+pub struct GameObject{
+  pub name: String,
+  pub active: bool,
+
+  pub transform: Transform,
+  pub mesh_renderer: Option<MeshRenderer>,
+  pub mesh_filter: Option<Mesh>,
+}
+
+pub fn load( path: &'static str ) -> anyhow::Result<Vec<GameObject>>{
+  let mesh_parser = MeshParser::new(UnityVersion::parse_version("2020.3.12f1").unwrap());
+
+  let mut env = Environment::new();
+  env.load(path)?;
+
+  let mut gameobjects = vec![];
+
+  for obj in env.objects(){
+    match obj{
+      EnvironmentObjectRef::Binary(v) => {
+        if v.object.class_id() == 1{
+          let obj = v.object.read()?;
+          let go = obj.as_gameobject().unwrap();
+
+          let mut components: Vec<Box<dyn Component>> = vec![];
+
+          let mut transform = None;
+          let mut mesh_renderer = None;
+          let mut mesh_filter = None;
+
+          let comps = obj.get("m_Component").unwrap().as_array().unwrap();
+
+          for comp in comps{
+            let obj = comp.as_object().unwrap().get("component").unwrap();
+            let path_id = obj.as_object().unwrap().get("m_PathID").unwrap().as_i64().unwrap();
+
+            let comp = env.find_binary_object(path_id).unwrap();
+            let comp = comp.read().unwrap();
+
+            match comp.class_id(){
+              4 => transform = Some(into_bevy_transform(comp)), // Normal Transform
+              224 => transform = Some(into_bevy_transform(comp)), // Rect Transform (gonna just treat it as normal)
+
+              23 => mesh_renderer = Some(MeshRenderer::from(comp)),
+              33 => {
+                let mesh = comp.get("m_Mesh").unwrap();
+                let path_id = mesh.as_object().unwrap().get("m_PathID").unwrap().as_i64().unwrap();
+
+                let mesh = env.find_binary_object(path_id).unwrap();
+                let mesh_obj = mesh.read().unwrap();
+
+                if let Some(mesh) = util::unity_value::try_unity_mesh_to_bevy(mesh_obj, &mesh_parser){
+                  mesh_filter = Some(mesh);
+                } else{
+                  println!("[WARN] Failed to load mesh for: {}", go.name);
+                }
+              },
+
+              _ => {}
+            }
+          }
+
+          if transform.is_none(){ bail!("Cannot find transform for object {}", go.name); }
+
+          let gameobject = GameObject {
+            name: go.name,
+            active: go.active,
+
+            transform: transform.unwrap(),
+            mesh_renderer,
+            mesh_filter
+          };
+
+          gameobjects.push(gameobject);
+          // break;
+        }
+      },
+      _ => {}
+    }
+  }
+
+  Ok(gameobjects)
+}

loader/src/util/mod.rs

···
+pub mod unity_value;

loader/src/util/unity_value.rs

···
+use std::{fs::File, io::Write};
+
+use bevy::{asset::RenderAssetUsages, math::{Quat, Vec3}, mesh::{Indices, PrimitiveTopology}, prelude::*};
+use unity_asset::UnityValue;
+use unity_asset_binary::object::UnityObject;
+use unity_asset_decode::mesh::MeshParser;
+
+pub fn unity_value_to_vec3( val: &UnityValue ) -> Vec3{
+  let obj = val.as_object().unwrap();
+
+  Vec3 {
+    x: obj.get("x").unwrap().as_f64().unwrap() as f32,
+    y: obj.get("y").unwrap().as_f64().unwrap() as f32,
+    z: obj.get("z").unwrap().as_f64().unwrap() as f32
+  }
+}
+
+pub fn unity_value_to_quat( val: &UnityValue ) -> Quat{
+  let obj = val.as_object().unwrap();
+
+  Quat::from_xyzw(
+    obj.get("x").unwrap().as_f64().unwrap() as f32,
+    obj.get("y").unwrap().as_f64().unwrap() as f32,
+    obj.get("z").unwrap().as_f64().unwrap() as f32,
+    obj.get("w").unwrap().as_f64().unwrap() as f32
+  )
+}
+
+fn get_channel_dtype( format: u8 ) -> String{
+  match format{
+    0 => "f", // kVertexFormatFloat
+    // 1 => "e", // kVertexFormatFloat16
+    2 => "B", // kVertexFormatUNorm8
+    3 => "b", // kVertexFormatSNorm8
+    4 => "H", // kVertexFormatUNorm16
+    5 => "h", // kVertexFormatSNorm16
+    6 => "B", // kVertexFormatUInt8
+    7 => "b", // kVertexFormatSInt8
+    8 => "H", // kVertexFormatUInt16
+    9 => "h", // kVertexFormatSInt16
+    10 => "I", // kVertexFormatUInt32
+    11 => "i", // kVertexFormatSInt32
+
+    _ => ""
+  }.into()
+}
+
+fn get_channel_component_size( format: u8 ) -> usize{
+  match format{
+    0 => 4, // kVertexFormatFloat
+    // 1 => 2, // kVertexFormatFloat16
+    2 => 1, // kVertexFormatUNorm8
+    3 => 1, // kVertexFormatSNorm8
+    4 => 2, // kVertexFormatUNorm16
+    5 => 2, // kVertexFormatSNorm16
+    6 => 1, // kVertexFormatUInt8
+    7 => 1, // kVertexFormatSInt8
+    8 => 2, // kVertexFormatUInt16
+    9 => 2, // kVertexFormatSInt16
+    10 => 4, // kVertexFormatUInt32
+    11 => 4, // kVertexFormatSInt32
+
+    _ => 0
+  }
+}
+
+enum UnityDataTypeArray{
+  kVertexFormatFloat(Vec<Vec<f32>>),
+  // kVertexFormatFloat16(Vec<Vec<f16>>),
+  kVertexFormatUNorm8(Vec<Vec<u8>>),
+  kVertexFormatSNorm8(Vec<Vec<i8>>),
+  kVertexFormatUNorm16(Vec<Vec<u16>>),
+  kVertexFormatSNorm16(Vec<Vec<i16>>),
+  kVertexFormatUInt8(Vec<Vec<u8>>),
+  kVertexFormatSInt8(Vec<Vec<i8>>),
+  kVertexFormatUInt16(Vec<Vec<u16>>),
+  kVertexFormatSInt16(Vec<Vec<i16>>),
+  kVertexFormatUInt32(Vec<Vec<u32>>),
+  kVertexFormatSInt32(Vec<Vec<i32>>),
+  Unknown
+}
+
+impl UnityDataTypeArray{
+  pub fn as_vec3_array( &self ) -> Vec<Vec3>{
+    if let Self::kVertexFormatFloat(array) = self{
+      let mut vecs = vec![];
+
+      for val in array{
+        vecs.push(Vec3 { x: val[0], y: val[1], z: val[2] });
+      }
+
+      vecs
+    } else{
+      panic!("Not a float array");
+    }
+  }
+}
+
+fn unpack_struct( dimension: usize, component_dtype: u8, bytes: Vec<u8> ) -> UnityDataTypeArray{
+  match component_dtype{
+    0 => {
+      let mut decoded: Vec<Vec<_>> = vec![];
+      let item_size = get_channel_component_size(component_dtype);
+      let vec_size = item_size * dimension;
+
+      for i in 0..( bytes.len() / vec_size ){
+        let indx = i * vec_size;
+        let mut vec = vec![0.0; dimension];
+
+        for j in 0..dimension{
+          vec[j] = f32::from_le_bytes([
+            bytes[indx + (j * item_size)],
+            bytes[indx + (j * item_size) + 1],
+            bytes[indx + (j * item_size) + 2],
+            bytes[indx + (j * item_size) + 3]
+          ]);
+        }
+        decoded.push(vec);
+      }
+
+      UnityDataTypeArray::kVertexFormatFloat(decoded)
+    },
+
+    2 => {
+      let mut decoded: Vec<Vec<u8>> = vec![];
+      let item_size = get_channel_component_size(component_dtype);
+      let vec_size = item_size * dimension;
+
+      for i in 0..( bytes.len() / vec_size ){
+        let indx = i * vec_size;
+        let mut vec = vec![0; vec_size];
+
+        for j in 0..vec_size{ vec[j] = u8::from_le_bytes([ bytes[indx + (j * item_size)] ]); }
+        decoded.push(vec);
+      }
+
+      UnityDataTypeArray::kVertexFormatUNorm8(decoded)
+    },
+
+    3 => {
+      let mut decoded: Vec<Vec<_>> = vec![];
+      let item_size = get_channel_component_size(component_dtype);
+      let vec_size = item_size * dimension;
+
+      for i in 0..( bytes.len() / vec_size ){
+        let indx = i * vec_size;
+        let mut vec = vec![0; vec_size];
+
+        for j in 0..vec_size{ vec[j] = i8::from_le_bytes([ bytes[indx + (j * item_size)] ]); }
+        decoded.push(vec);
+      }
+
+      UnityDataTypeArray::kVertexFormatSNorm8(decoded)
+    },
+
+    4 => {
+      let mut decoded: Vec<Vec<_>> = vec![];
+      let item_size = get_channel_component_size(component_dtype);
+      let vec_size = item_size * dimension;
+
+      for i in 0..( bytes.len() / vec_size ){
+        let indx = i * vec_size;
+        let mut vec = vec![0; vec_size];
+
+        for j in 0..vec_size{
+          vec[j] = u16::from_le_bytes([
+            bytes[indx + (j * item_size)],
+            bytes[indx + (j * item_size) + 1]
+          ]);
+        }
+        decoded.push(vec);
+      }
+
+      UnityDataTypeArray::kVertexFormatUNorm16(decoded)
+    },
+
+    5 => {
+      let mut decoded: Vec<Vec<_>> = vec![];
+      let item_size = get_channel_component_size(component_dtype);
+      let vec_size = item_size * dimension;
+
+      for i in 0..( bytes.len() / vec_size ){
+        let indx = i * vec_size;
+        let mut vec = vec![0; vec_size];
+
+        for j in 0..vec_size{
+          vec[j] = i16::from_le_bytes([
+            bytes[indx + (j * item_size)],
+            bytes[indx + (j * item_size) + 1]
+          ]);
+        }
+        decoded.push(vec);
+      }
+
+      UnityDataTypeArray::kVertexFormatSNorm16(decoded)
+    },
+
+    6 => {
+      let mut decoded: Vec<Vec<u8>> = vec![];
+      let item_size = get_channel_component_size(component_dtype);
+      let vec_size = item_size * dimension;
+
+      for i in 0..( bytes.len() / vec_size ){
+        let indx = i * vec_size;
+        let mut vec = vec![0; vec_size];
+
+        for j in 0..vec_size{ vec[j] = u8::from_le_bytes([ bytes[indx + (j * item_size)] ]); }
+        decoded.push(vec);
+      }
+
+      UnityDataTypeArray::kVertexFormatUInt8(decoded)
+    },
+
+    7 => {
+      let mut decoded: Vec<Vec<_>> = vec![];
+      let item_size = get_channel_component_size(component_dtype);
+      let vec_size = item_size * dimension;
+
+      for i in 0..( bytes.len() / vec_size ){
+        let indx = i * vec_size;
+        let mut vec = vec![0; vec_size];
+
+        for j in 0..vec_size{ vec[j] = i8::from_le_bytes([ bytes[indx + (j * item_size)] ]); }
+        decoded.push(vec);
+      }
+
+      UnityDataTypeArray::kVertexFormatSInt8(decoded)
+    },
+
+    8 => {
+      let mut decoded: Vec<Vec<_>> = vec![];
+      let item_size = get_channel_component_size(component_dtype);
+      let vec_size = item_size * dimension;
+
+      for i in 0..( bytes.len() / vec_size ){
+        let indx = i * vec_size;
+        let mut vec = vec![0; vec_size];
+
+        for j in 0..vec_size{
+          vec[j] = u16::from_le_bytes([
+            bytes[indx + (j * item_size)],
+            bytes[indx + (j * item_size) + 1]
+          ]);
+        }
+        decoded.push(vec);
+      }
+
+      UnityDataTypeArray::kVertexFormatUInt16(decoded)
+    },
+
+    9 => {
+      let mut decoded: Vec<Vec<_>> = vec![];
+      let item_size = get_channel_component_size(component_dtype);
+      let vec_size = item_size * dimension;
+
+      for i in 0..( bytes.len() / vec_size ){
+        let indx = i * vec_size;
+        let mut vec = vec![0; vec_size];
+
+        for j in 0..vec_size{
+          vec[j] = i16::from_le_bytes([
+            bytes[indx + (j * item_size)],
+            bytes[indx + (j * item_size) + 1]
+          ]);
+        }
+        decoded.push(vec);
+      }
+
+      UnityDataTypeArray::kVertexFormatSInt16(decoded)
+    },
+
+    10 => {
+      let mut decoded: Vec<Vec<_>> = vec![];
+      let item_size = get_channel_component_size(component_dtype);
+      let vec_size = item_size * dimension;
+
+      for i in 0..( bytes.len() / vec_size ){
+        let indx = i * vec_size;
+        let mut vec = vec![0; vec_size];
+
+        for j in 0..vec_size{
+          vec[j] = u32::from_le_bytes([
+            bytes[indx + (j * item_size)],
+            bytes[indx + (j * item_size) + 1],
+            bytes[indx + (j * item_size) + 2],
+            bytes[indx + (j * item_size) + 3]
+          ]);
+        }
+        decoded.push(vec);
+      }
+
+      UnityDataTypeArray::kVertexFormatUInt32(decoded)
+    },
+
+    11 => {
+      let mut decoded: Vec<Vec<_>> = vec![];
+      let item_size = get_channel_component_size(component_dtype);
+      let vec_size = item_size * dimension;
+
+      for i in 0..( bytes.len() / vec_size ){
+        let indx = i * vec_size;
+        let mut vec = vec![0; vec_size];
+
+        for j in 0..vec_size{
+          vec[j] = i32::from_le_bytes([
+            bytes[indx + (j * item_size)],
+            bytes[indx + (j * item_size) + 1],
+            bytes[indx + (j * item_size) + 2],
+            bytes[indx + (j * item_size) + 3]
+          ]);
+        }
+        decoded.push(vec);
+      }
+
+      UnityDataTypeArray::kVertexFormatSInt32(decoded)
+    },
+
+    _ => { UnityDataTypeArray::Unknown }
+  }
+}
+
+struct StreamInfo{
+  channel_mask: usize,
+  offset: usize,
+  stride: usize
+}
+
+pub fn try_unity_mesh_to_bevy( mesh_obj: UnityObject, mesh_parser: &MeshParser ) -> Option<Mesh>{
+  let mut vertices = None;
+  let mut normals = None;
+  let mut tangents = None;
+  let mut uv0 = None;
+
+  let mesh = mesh_parser.parse_from_unity_object(&mesh_obj).unwrap().mesh;
+  let vertex_data = mesh.vertex_data;
+
+  let mut streams = vec![];
+  let stream_count = 1 + vertex_data.channels.iter().map(|x| x.stream).max()?;
+
+  let mut offset = 0;
+
+  for s in 0..stream_count{
+    let mut chn_mask = 0;
+    let mut stride = 0;
+
+    let mut i = 0;
+    for channel in &vertex_data.channels{
+      if channel.stream == s && channel.dimension > 0{
+        chn_mask |= 1 << i;
+
+        let component_size = get_channel_component_size(channel.format);
+        stride += (channel.dimension & 0xF) as usize * component_size;
+      }
+
+      streams.push(StreamInfo {
+        channel_mask: chn_mask,
+        offset,
+        stride
+      });
+
+      offset += vertex_data.vertex_count as usize * stride;
+      offset = ( offset + ( 16 - 1 ) ) & !(16 - 1);
+
+      i += 1;
+    }
+  }
+
+  let mut i = 0;
+  for channel in vertex_data.channels{
+    let stream = &streams[channel.stream as usize];
+
+    if stream.channel_mask >> i & 1 == 1{
+      let component_byte_size = get_channel_component_size(channel.format);
+      let channel_dimension = (channel.dimension & 0xF) as usize;
+
+      let mut bytes =
+        vec![0; vertex_data.vertex_count as usize * channel_dimension * component_byte_size];
+
+      dbg!(vertex_data.vertex_count);
+
+      let vertex_base_offset = stream.offset + channel.offset as usize;
+      for v in 0..vertex_data.vertex_count{
+        let vertex_offset = vertex_base_offset + stream.stride * v as usize;
+
+        for d in 0..channel_dimension{
+          let vertex_data_src = vertex_offset + component_byte_size * d as usize;
+          let component_data_src = component_byte_size * ( v as usize * channel_dimension + d as usize );
+
+          let buff = vertex_data.data_size[vertex_data_src..vertex_data_src + component_byte_size].to_vec();
+          bytes.splice(component_data_src..component_data_src + component_byte_size, buff);
+        }
+      }
+
+      let component_data = unpack_struct(channel_dimension, channel.format, bytes);
+
+      match i{
+        0 => vertices = Some(component_data),
+        1 => normals = Some(component_data),
+        2 => tangents = Some(component_data),
+        4 => uv0 = Some(component_data),
+
+        _ => {}
+      }
+    }
+
+    i += 1;
+  }
+
+  let mut triangles = vec![];
+  if mesh.index_buffer.len() > 0{
+    for submesh in mesh.sub_meshes{
+      let first_index = submesh.first_byte / 4;
+      let triangle_count = submesh.index_count / 6;
+
+      for i in 0..triangle_count{
+        let indx = i * 6;
+
+        triangles.push(u16::from_le_bytes([
+          mesh.index_buffer[(first_index + indx) as usize],
+          mesh.index_buffer[(first_index + indx + 1) as usize]
+        ]));
+
+        triangles.push(u16::from_le_bytes([
+          mesh.index_buffer[(first_index + indx + 2) as usize],
+          mesh.index_buffer[(first_index + indx + 3) as usize]
+        ]));
+
+        triangles.push(u16::from_le_bytes([
+          mesh.index_buffer[(first_index + indx + 4) as usize],
+          mesh.index_buffer[(first_index + indx + 5) as usize]
+        ]));
+      }
+    }
+  } else{
+    return None;
+  }
+
+  if vertices.is_none(){ panic!("Cannot parse vertices") }
+  let vertices = vertices.unwrap().as_vec3_array();
+
+  let mut file = File::create("test.obj").unwrap();
+
+  for vec in &vertices{
+    writeln!(file, "v {} {} {}", vec.x, vec.y, vec.z).unwrap();
+  }
+
+  for i in 0..(triangles.len() / 3){
+    let indx = i * 3;
+    writeln!(file, "f {} {} {}", triangles[indx], triangles[indx + 1], triangles[indx + 2]).unwrap();
+  }
+
+  Some(Mesh::new(PrimitiveTopology::TriangleList, RenderAssetUsages::MAIN_WORLD | RenderAssetUsages::RENDER_WORLD)
+    .with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, vertices)
+    .with_inserted_indices(Indices::U16(triangles)))
+}