Struct WaveSimulation 

pub struct WaveSimulation {
    pub width: usize,
    pub height: usize,
    pub current: Vec<f32>,
    pub previous: Vec<f32>,
    pub speed: f32,
    pub damping: f32,
    pub fixed_boundaries: bool,
}

2D wave equation simulation on a grid.

Simulates wave propagation using the discretized wave equation: u(t+1) = 2*u(t) - u(t-1) + c^2 * dt^2 * laplacian(u)

Fields

width: usize

Grid width.

height: usize

Grid height.

current: Vec<f32>

Current displacement values.

previous: Vec<f32>

Previous frame displacement values.

speed: f32

Wave propagation speed.

damping: f32

Damping factor (0 = no damping, higher = more damping).

fixed_boundaries: bool

Boundary condition: if true, edges are fixed at zero.

Implementations

impl WaveSimulation

pub fn new(width: usize, height: usize, speed: f32) -> Self

Create a new wave simulation grid.

pub fn with_damping(self, damping: f32) -> Self

Set damping factor.

pub fn with_fixed_boundaries(self, fixed: bool) -> Self

Set boundary condition.

pub fn reset(&mut self)

Reset the simulation to zero.

pub fn displace(&mut self, x: usize, y: usize, amount: f32)

Add a displacement at a grid point.

pub fn impulse(&mut self, cx: f32, cy: f32, radius: f32, amplitude: f32)

Add a circular impulse at a position.

pub fn oscillator( &mut self, x: usize, y: usize, time: f32, frequency: f32, amplitude: f32, )

Add a sinusoidal source at a point (continuous oscillation).

pub fn step(&mut self, dt: f32)

Step the simulation by dt.

pub fn get(&self, x: usize, y: usize) -> f32

Get the displacement at a grid point.

pub fn sample(&self, x: f32, y: f32) -> f32

Sample displacement at a fractional position using bilinear interpolation.

pub fn normal_at(&self, x: usize, y: usize, scale: f32) -> Vec3

Compute the normal at a grid point (for rendering the wave as a surface).

pub fn total_energy(&self) -> f32

Get the total energy in the system.

pub fn to_displacements(&self) -> Vec<f32>

Convert the wave simulation to a displacement array for a surface mesh. Maps grid coordinates to vertex displacement amounts.

pub fn apply_to_grid( &self, positions: &mut [Vec3], grid_width: usize, grid_height: usize, )

Apply the wave simulation as displacement to a flat grid of positions.