Wave Functions

fn chirpWave(x: f32, startFrequency: f32, endFrequency: f32, amplitude: f32, period: f32) -> f32 {
  // Calculate the time within the current period
  let t = fract(x / period);
  
  // Calculate the frequency at the current time (linear interpolation)
  let freq = mix(startFrequency, endFrequency, t);
  
  // Calculate the phase which increases with changing frequency
  let k = (endFrequency - startFrequency) / period;
  let phase = 2.0 * 3.14159 * (startFrequency * t + 0.5 * k * t * t);
  
  // Return the sine wave with the calculated phase
  return sin(phase) * amplitude;
}

//! requires hash1D
fn noiseWave(x: f32, frequency: f32, amplitude: f32, seed: f32) -> f32 {
  // Create interpolated noise
  let t = x * frequency;
  let floorT = floor(t);
  let fractT = fract(t);
  
  // Get four noise values and interpolate between them
  let n0 = hash1D(floorT + seed);
  let n1 = hash1D(floorT + 1.0 + seed);
  
  // Smooth interpolation
  let u = fractT * fractT * (3.0 - 2.0 * fractT); // Smoothstep
  
  return mix(n0, n1, u) * amplitude;
}

fn pulseWave(x: f32, frequency: f32, amplitude: f32, phase: f32, width: f32, falloff: f32) -> f32 {
  let t = x * frequency + phase;
  let tt = fract(t);
  
  // Create a pulse with smooth edges
  var pulse = 0.0;
  
  // If tt is within the width, pulse is 1.0
  if (tt < width) {
    pulse = 1.0;
  } else if (tt < width + falloff) {
    // Smooth falloff
    pulse = 1.0 - (tt - width) / falloff;
  }
  
  return pulse * amplitude;
}

fn triangleWave(x: f32, frequency: f32, amplitude: f32, phase: f32) -> f32 {
  let t = x * frequency + phase;
  let tt = fract(t);
  let result = abs(2.0 * tt - 1.0);
  return (1.0 - result) * amplitude;
}