Added a simple on hit audio component. Cleanup some other stuff

amicloud · amicloud · commit 37e70a664f45 · 2026-02-26T00:56:00.000-08:00
diff --git a/engine/benches/my_benchmark.rs b/engine/benches/my_benchmark.rs
@@ -6,10 +6,7 @@ use engine::render::render_body_resource::RenderBodyResource;
 use std::hint::black_box;
 
 use engine::physics::physics_resource::{CollisionFrameData, PhysicsResource};
-use engine::{
-    CollisionLayer, CollisionSystem, ConvexCollider, TimeResource,
-    TransformComponent,
-};
+use engine::{CollisionLayer, CollisionSystem, ConvexCollider, TimeResource, TransformComponent};
 use glam::{Quat, Vec3};
 
 fn spawn_convex_grid(world: &mut World, count: usize, spacing: f32, radius: f32) {
diff --git a/engine/src/audio/mod.rs b/engine/src/audio/mod.rs
@@ -1,6 +1,7 @@
 pub mod audio_command_queue;
 pub mod audio_command_queue_system;
 pub mod audio_mixer;
+pub mod simple_phys_audio_system;
 pub mod spatial_audio_system;
 pub mod track;
 pub mod voice;
diff --git a/engine/src/audio/simple_phys_audio_system.rs b/engine/src/audio/simple_phys_audio_system.rs
@@ -0,0 +1,104 @@
+use bevy_ecs::prelude::*;
+use glam::Vec3;
+
+use crate::{
+    TransformComponent,
+    audio::audio_command_queue::{AudioCommand, AudioCommandQueue},
+    components::simple_on_hit_audio_component::SimpleOnHitAudioComponent,
+    physics::{
+        collision_system::ordered_pair, physics_event::PhysicsEventType,
+        physics_resource::CollisionFrameData,
+    },
+};
+
+pub struct SimplePhysAudioSystem {}
+
+impl SimplePhysAudioSystem {
+    pub fn on_hit_audio_system(
+        query: Query<(&SimpleOnHitAudioComponent, &TransformComponent)>,
+        collision_frame_data: Res<CollisionFrameData>,
+        mut audio_command_queue: ResMut<AudioCommandQueue>,
+    ) {
+        for manifold_entry in collision_frame_data.manifolds.iter() {
+            let pair = ordered_pair(manifold_entry.entity_a, manifold_entry.entity_b);
+            let event_type = if collision_frame_data.previous_manifolds.get(pair).is_some() {
+                PhysicsEventType::Stay
+            } else {
+                PhysicsEventType::Hit
+            };
+
+            match event_type {
+                PhysicsEventType::Hit => {
+                    if query.get(manifold_entry.entity_a).is_ok() {
+                        let volume = query.get(manifold_entry.entity_a).unwrap().0.volume;
+                        let force_modifier = query
+                            .get(manifold_entry.entity_a)
+                            .unwrap()
+                            .0
+                            .force_volume_scale;
+                        let contact_force = manifold_entry
+                            .manifold
+                            .contacts
+                            .iter()
+                            .map(|c| c.penetration)
+                            .sum::<f32>();
+                        let final_volume =
+                            volume * (contact_force * force_modifier).clamp(0.0, 1.0);
+                        dbg!(final_volume);
+                        let sound_position = manifold_entry
+                            .manifold
+                            .contacts
+                            .iter()
+                            .map(|c| c.contact_point)
+                            .sum::<Vec3>()
+                            / manifold_entry.manifold.contacts.len() as f32;
+                        audio_command_queue
+                            .queue
+                            .push(AudioCommand::PlaySoundAtLocation {
+                                track: 0,
+                                sound: query.get(manifold_entry.entity_a).unwrap().0.sound_handle,
+                                volume: final_volume,
+                                looping: false,
+                                location: sound_position,
+                            });
+                    }
+
+                    if query.get(manifold_entry.entity_b).is_ok() {
+                        let volume = query.get(manifold_entry.entity_b).unwrap().0.volume;
+                        let force_modifier = query
+                            .get(manifold_entry.entity_b)
+                            .unwrap()
+                            .0
+                            .force_volume_scale;
+                        let contact_force = manifold_entry
+                            .manifold
+                            .contacts
+                            .iter()
+                            .map(|c| c.penetration)
+                            .sum::<f32>();
+                        let final_volume =
+                            volume * (contact_force * force_modifier).clamp(0.0, 1.0);
+                        dbg!(final_volume);
+                        let sound_position = manifold_entry
+                            .manifold
+                            .contacts
+                            .iter()
+                            .map(|c| c.contact_point)
+                            .sum::<Vec3>()
+                            / manifold_entry.manifold.contacts.len() as f32;
+                        audio_command_queue
+                            .queue
+                            .push(AudioCommand::PlaySoundAtLocation {
+                                track: 0,
+                                sound: query.get(manifold_entry.entity_b).unwrap().0.sound_handle,
+                                volume: final_volume,
+                                looping: false,
+                                location: sound_position,
+                            });
+                    }
+                }
+                PhysicsEventType::Stay => continue,
+            }
+        }
+    }
+}
diff --git a/engine/src/audio/voice.rs b/engine/src/audio/voice.rs
@@ -5,11 +5,11 @@ use glam::Vec3;
 
 use crate::audio::audio_mixer::ListenerInfo;
 
-const ITD_DELAY_BUFFER_SIZE: usize = 64; // Must be a power of two
+const ITD_DELAY_BUFFER_SIZE: usize = 128;
 const DEFAULT_SAMPLE_RATE_HZ: f32 = 44_100.0;
 const PAN_SMOOTH_TIME_SECONDS: f32 = 0.05;
 const BACK_LPF_MIX_MULT: f32 = 0.8;
-const LPF_CUTOFF_HZ: f32 = 200.0;
+const LPF_CUTOFF_HZ: f32 = 400.0;
 
 #[derive(Debug)]
 pub(crate) struct Voice {
@@ -157,6 +157,7 @@ impl Voice {
         // Even though one side will always have a 0 sample delay let's just do the math for both sides to avoid
         // doing a ton of if statement evaluations each frame.
         let delay_signed = self.pan_smoothed * self.itd_delay.range as f32;
+        // let delay_signed:f32 = 0.0;
         let left_delay = delay_signed.max(0.0);
         let right_delay = (-delay_signed).max(0.0);
         let itd_range_f32 = self.itd_delay.range as f32;
diff --git a/engine/src/components/mod.rs b/engine/src/components/mod.rs
@@ -5,6 +5,7 @@ pub mod material_component;
 pub mod physics_component;
 pub mod physics_event_listener_component;
 pub mod render_body_component;
+pub mod simple_on_hit_audio_component;
 pub mod single_audio_listener_component;
 pub mod sleep_component;
 pub mod transform_component;
diff --git a/engine/src/components/simple_on_hit_audio_component.rs b/engine/src/components/simple_on_hit_audio_component.rs
@@ -0,0 +1,11 @@
+use bevy_ecs::prelude::*;
+
+use crate::SoundHandle;
+
+#[derive(Component)]
+pub struct SimpleOnHitAudioComponent {
+    pub sound_handle: SoundHandle,
+    pub volume: f32,
+    pub pitch: f32,
+    pub force_volume_scale: f32,
+}
diff --git a/engine/src/lib.rs b/engine/src/lib.rs
@@ -23,11 +23,15 @@ use glam::{Mat4, Vec3};
 use glow::HasContext;
 
 use crate::{
-    assets::{material_resource::MaterialResource, mesh_resource::MeshResource, shader_resource::ShaderResource, sound_resource::SoundResource, texture_resource::TextureResource},
+    assets::{
+        material_resource::MaterialResource, mesh_resource::MeshResource,
+        shader_resource::ShaderResource, sound_resource::SoundResource,
+        texture_resource::TextureResource,
+    },
     audio::{
         audio_command_queue::AudioCommandQueue,
         audio_command_queue_system::AudioCommandQueueSystem, audio_mixer::AudioMixer,
-        spatial_audio_system::SpatialAudioSystem,
+        simple_phys_audio_system::SimplePhysAudioSystem, spatial_audio_system::SpatialAudioSystem,
     },
     components::physics_component::PhysicsComponent,
     input::InputStateResource,
@@ -38,7 +42,10 @@ use crate::{
         physics_system::PhysicsSystem,
     },
     render::{
-        render_body_resource::RenderBodyResource, render_queue::RenderQueue, render_system::RenderSystem, renderer::{CameraRenderData, RenderParams, Renderer}
+        render_body_resource::RenderBodyResource,
+        render_queue::RenderQueue,
+        render_system::RenderSystem,
+        renderer::{CameraRenderData, RenderParams, Renderer},
     },
     utils::scope_timer::ScopeTimer,
 };
@@ -124,6 +131,7 @@ impl Engine {
                 AudioCommandQueueSystem::build_command_queue,
                 SpatialAudioSystem::update_listener_position,
                 SpatialAudioSystem::update_source_positions,
+                SimplePhysAudioSystem::on_hit_audio_system,
             )
                 .chain(),
         );
@@ -253,10 +261,10 @@ impl Engine {
 
                     self.renderer.render(
                         render_params,
-                        &mesh_resource,
-                        &material_resource,
-                        &texture_resource,
-                        &shader_resource,
+                        mesh_resource,
+                        material_resource,
+                        texture_resource,
+                        shader_resource,
                         camera_data,
                     );
                 }
diff --git a/engine/src/physics/collision_system.rs b/engine/src/physics/collision_system.rs
@@ -47,9 +47,11 @@ impl CollisionSystem {
         for (entity, transform, convex_collider, mesh_collider) in &query {
             // --- 1. Compute world AABB ---
             let world_aabb = if let Some(mesh_collider) = mesh_collider {
-                if let Some(local_aabb) =
-                    render_body_local_aabb(mesh_collider.render_body_id, &render_body_resource, &mesh_resource)
-                {
+                if let Some(local_aabb) = render_body_local_aabb(
+                    mesh_collider.render_body_id,
+                    &render_body_resource,
+                    &mesh_resource,
+                ) {
                     transform_aabb(local_aabb, transform)
                 } else {
                     continue;
@@ -112,8 +114,11 @@ impl CollisionSystem {
     ) {
         for (entity, transform, convex_collider, mesh_collider) in &query {
             if let Some(mesh_collider) = mesh_collider
-                && let Some(local_aabb) =
-                    render_body_local_aabb(mesh_collider.render_body_id, &render_body_resource, &mesh_resource)
+                && let Some(local_aabb) = render_body_local_aabb(
+                    mesh_collider.render_body_id,
+                    &render_body_resource,
+                    &mesh_resource,
+                )
             {
                 let world_aabb = transform_aabb(local_aabb, transform);
                 phys.world_aabbs.insert(entity, world_aabb);
diff --git a/engine/src/render/render_system.rs b/engine/src/render/render_system.rs
@@ -5,7 +5,8 @@ use crate::{
         render_body_component::RenderBodyComponent, transform_component::TransformComponent,
     },
     render::{
-        render_body_resource::RenderBodyResource, render_instance::RenderInstance, render_queue::RenderQueue
+        render_body_resource::RenderBodyResource, render_instance::RenderInstance,
+        render_queue::RenderQueue,
     },
 };
 
diff --git a/engine/src/render/renderer.rs b/engine/src/render/renderer.rs
@@ -18,9 +18,7 @@ use crate::{
         texture,
         texture_resource::TextureResource,
     },
-    render::{
-        frustum::Frustum, render_body_resource::RenderBodyResource, render_instance::RenderInstance,
-    },
+    render::{frustum::Frustum, render_instance::RenderInstance},
 };
 
 pub struct Renderer {
@@ -503,9 +501,7 @@ impl Renderer {
         }
 
         if !mesh_render_data.contains_key(mesh) {
-            let mesh_data = mesh_resource
-                .get_mesh(mesh)
-                .expect("Mesh not found");
+            let mesh_data = mesh_resource.get_mesh(mesh).expect("Mesh not found");
             Self::upload_mesh_to_gpu(gl, mesh_data, mesh, mesh_render_data);
         }
 
@@ -529,11 +525,7 @@ impl Renderer {
                 None
             };
 
-            for attrib in &shader_resource
-                .get_shader(*shader)
-                .unwrap()
-                .attributes
-            {
+            for attrib in &shader_resource.get_shader(*shader).unwrap().attributes {
                 let location = attrib.location;
                 let divisor = match attrib.rate {
                     PerVertex => 0,
diff --git a/game/src/game_controller.rs b/game/src/game_controller.rs
@@ -1,7 +1,6 @@
 use bevy_ecs::prelude::*;
 use engine::assets::sound_resource::SoundResource;
 use engine::audio::audio_command_queue::{AudioCommand, AudioCommandQueue};
-use engine::components::audio_source_component::AudioSourceComponent;
 use engine::input::InputStateResource;
 use engine::{Gravity, TimeResource, TransformComponent, WorldBasis};
 use glam::{Quat, Vec3};
@@ -85,15 +84,10 @@ pub fn sound_control(
 }
 
 pub fn spatial_audio_orbit_demo(
-    mut query: Query<(
-        Entity,
-        &mut TransformComponent,
-        &AudioSourceComponent,
-        &SpatialAudioDemoComponent,
-    )>,
+    mut query: Query<(Entity, &mut TransformComponent, &SpatialAudioDemoComponent)>,
     time: Res<TimeResource>,
 ) {
-    for (_, mut transform, _, _) in query.iter_mut() {
+    for (_, mut transform, _) in query.iter_mut() {
         let rotation_speed = 0.5; // Radians per second
         let angle = time.total_time() * rotation_speed;
         let radius = 5.0;
@@ -114,14 +108,13 @@ pub fn spatial_audio_popping_demo(
     mut audio_command_queue: ResMut<AudioCommandQueue>,
     sound_resource: Res<SoundResource>,
 ) {
-    if time.frame_count().is_multiple_of(20) {
-        let (x, y, z) = rand::random::<(f32, f32, f32)>();
-        let random_dir = Vec3::new(x, y, z).normalize_or_zero();
-        let position = random_dir * 5.0;
+    if time.frame_count().is_multiple_of(120) {
+        eprint!("POP!");
+        let position = Vec3::new(5.0, 0.0, 2.0);
         audio_command_queue.push(AudioCommand::PlaySoundAtLocation {
             track: 0,
             sound: sound_resource.get_by_name("pop.wav").unwrap(),
-            volume: 1.0,
+            volume: 2.0,
             looping: false,
             location: position,
         });
diff --git a/game/src/main.rs b/game/src/main.rs
