310 lines
8.9 KiB
GDScript
310 lines
8.9 KiB
GDScript
extends RefCounted
|
|
class_name SfxrGenerator
|
|
|
|
|
|
var params
|
|
|
|
var wave_shape: int
|
|
|
|
var repeat_time: float
|
|
var elapsed_since_repeat: float
|
|
|
|
var arpeggio_time: int
|
|
var arpeggio_multiplier: float
|
|
|
|
var period: float
|
|
var period_mult: float
|
|
var period_mult_slide: float
|
|
var period_max: float
|
|
|
|
var enable_frequency_cutoff: bool
|
|
|
|
var duty_cycle: float
|
|
var duty_cycle_slide: float
|
|
|
|
var fltw: float
|
|
var fltw_d: float
|
|
var fltdmp: float
|
|
var flthp: float
|
|
var flthp_d: float
|
|
var enable_low_pass_filter: bool
|
|
|
|
var vibrato_speed: float
|
|
var vibrato_amplitude: float
|
|
|
|
var envelope_length: Array
|
|
var envelope_punch: float
|
|
|
|
var flanger_offset: float
|
|
var flanger_offset_slide: float
|
|
|
|
var gain: float
|
|
var sample_rate: float
|
|
|
|
|
|
func init_params(stream_player) -> void:
|
|
params = stream_player
|
|
|
|
prepare_values()
|
|
|
|
# Wave shape
|
|
wave_shape = params.wave_type
|
|
|
|
# Filter
|
|
fltw = pow(params.p_lpf_freq, 3.0) * 0.1
|
|
enable_low_pass_filter = params.p_lpf_freq != 1.0
|
|
fltw_d = 1.0 + params.p_lpf_ramp * 0.0001
|
|
fltdmp = 5.0 / (1.0 + pow(params.p_lpf_resonance, 2.0) * 20.0) * (0.01 + fltw)
|
|
if (fltdmp > 0.8):
|
|
fltdmp = 0.8
|
|
flthp = pow(params.p_hpf_freq, 2.0) * 0.1
|
|
flthp_d = 1 + params.p_hpf_ramp * 0.0003
|
|
|
|
# Vibrato
|
|
vibrato_speed = pow(params.p_vib_speed, 2.0) * 0.01
|
|
vibrato_amplitude = params.p_vib_strength * 0.5
|
|
|
|
# Envelope
|
|
envelope_length = [
|
|
floor(params.p_env_attack * params.p_env_attack * 100000.0),
|
|
floor(params.p_env_sustain * params.p_env_sustain * 100000.0),
|
|
floor(params.p_env_decay * params.p_env_decay * 100000.0),
|
|
]
|
|
envelope_punch = params.p_env_punch
|
|
|
|
# Flanger
|
|
flanger_offset = pow(params.p_pha_offset, 2.0) * 1020.0
|
|
if (params.p_pha_offset < 0.0):
|
|
flanger_offset = -flanger_offset
|
|
flanger_offset_slide = pow(params.p_pha_ramp, 2.0) * 1.0
|
|
if (params.p_pha_ramp < 0.0):
|
|
flanger_offset_slide = -flanger_offset_slide
|
|
|
|
# Repeat
|
|
repeat_time = floor(pow(1 - params.p_repeat_speed, 2.0) * 20000.0 + 32.0)
|
|
if (params.p_repeat_speed == 0.0):
|
|
repeat_time = 0.0
|
|
|
|
gain = exp(params.sound_vol) - 1.0
|
|
sample_rate = params.sample_rate
|
|
|
|
|
|
func prepare_values() -> void:
|
|
elapsed_since_repeat = 0.0
|
|
|
|
period = 100.0 / (params.p_base_freq * params.p_base_freq + 0.001)
|
|
period_max = 100.0 / (params.p_freq_limit * params.p_freq_limit + 0.001)
|
|
enable_frequency_cutoff = params.p_freq_limit > 0.0
|
|
period_mult = 1.0 - pow(params.p_freq_ramp, 3.0) * 0.01
|
|
period_mult_slide = -pow(params.p_freq_dramp, 3.0) * 0.000001
|
|
|
|
duty_cycle = 0.5 - params.p_duty * 0.5
|
|
duty_cycle_slide = -params.p_duty_ramp * 0.00005
|
|
|
|
if (params.p_arp_mod >= 0.0):
|
|
arpeggio_multiplier = 1.0 - pow(params.p_arp_mod, 2.0) * 0.9
|
|
else:
|
|
arpeggio_multiplier = 1.0 + pow(params.p_arp_mod, 2.0) * 10.0
|
|
arpeggio_time = floor(pow(1.0 - params.p_arp_speed, 2.0) * 20000.0 + 32.0)
|
|
if (params.p_arp_speed == 1.0):
|
|
arpeggio_time = 0
|
|
|
|
|
|
func get_raw_buffer() -> Array:
|
|
randomize()
|
|
|
|
var fltp: float = 0.0
|
|
var fltdp: float = 0.0
|
|
var fltphp: float = 0.0
|
|
|
|
var noise_buffer_length: int = 32
|
|
var noise_buffer: Array = []
|
|
for i in noise_buffer_length:
|
|
noise_buffer.append(randf() * 2.0 - 1.0)
|
|
|
|
var envelope_stage: int = 0
|
|
var envelope_elapsed: float = 0.0
|
|
|
|
var vibrato_phase: float = 0.0
|
|
|
|
var phase: int = 0
|
|
var ipp: int = 0
|
|
var flanger_buffer_length: int = 1024
|
|
var flanger_buffer: Array = []
|
|
for i in flanger_buffer_length:
|
|
flanger_buffer.append(0.0)
|
|
|
|
var _buffer: Array = []
|
|
|
|
var sample_sum: float = 0.0
|
|
var num_summed: float = 0.0
|
|
var summands: int = floor(44100.0 / sample_rate)
|
|
|
|
var t: float = -1.0
|
|
while t < INF:
|
|
t += 1
|
|
|
|
# Repeats
|
|
elapsed_since_repeat += 1.0
|
|
if (repeat_time != 0.0 and elapsed_since_repeat >= repeat_time):
|
|
prepare_values()
|
|
|
|
# Arpeggio (single)
|
|
if (arpeggio_time != 0 and t >= arpeggio_time):
|
|
arpeggio_time = 0
|
|
period *= arpeggio_multiplier
|
|
|
|
# Frequency slide, and frequency slide slide!
|
|
period_mult += period_mult_slide
|
|
period *= period_mult
|
|
if (period > period_max):
|
|
period = period_max
|
|
if (enable_frequency_cutoff):
|
|
break
|
|
|
|
# Vibrato
|
|
var rfperiod: float = period
|
|
if (vibrato_amplitude > 0.0):
|
|
vibrato_phase += vibrato_speed
|
|
rfperiod = period * (1.0 + sin(vibrato_phase) * vibrato_amplitude)
|
|
var iperiod: int = floor(rfperiod)
|
|
if (iperiod < SfxrGlobals.OVERSAMPLING):
|
|
iperiod = SfxrGlobals.OVERSAMPLING
|
|
|
|
# Square wave duty cycle
|
|
duty_cycle = duty_cycle + duty_cycle_slide
|
|
if (duty_cycle > 0.5):
|
|
duty_cycle = 0.5
|
|
elif (duty_cycle < 0.0):
|
|
duty_cycle = 0.0
|
|
|
|
# Volume envelope
|
|
envelope_elapsed += 1.0
|
|
if (envelope_elapsed > envelope_length[envelope_stage]):
|
|
envelope_elapsed = 0.0
|
|
envelope_stage += 1.0
|
|
if (envelope_stage > 2.0):
|
|
break
|
|
|
|
if (envelope_length[envelope_stage] == 0):
|
|
continue
|
|
|
|
var env_vol: float = 0.0
|
|
var envf: float = envelope_elapsed / envelope_length[envelope_stage]
|
|
if (envelope_stage == 0.0): # Attack
|
|
env_vol = envf
|
|
elif (envelope_stage == 1.0): # Sustain
|
|
env_vol = 1.0 + (1.0 - envf) * 2.0 * envelope_punch
|
|
else: # Decay
|
|
env_vol = 1.0 - envf
|
|
|
|
# Flanger step
|
|
flanger_offset += flanger_offset_slide
|
|
var iphase: int = abs(floor(flanger_offset))
|
|
if (iphase > 1023):
|
|
iphase = 1023
|
|
|
|
if (flthp_d != 0.0):
|
|
flthp = flthp * flthp_d
|
|
if (flthp > 0.1):
|
|
flthp = 0.1
|
|
elif (flthp < 0.00001):
|
|
flthp = 0.00001
|
|
|
|
# 8x Oversampling
|
|
var sample: float = 0.0
|
|
for i in SfxrGlobals.OVERSAMPLING:
|
|
var sub_sample: float = 0.0
|
|
phase += 1
|
|
if (phase >= iperiod):
|
|
phase %= iperiod
|
|
if (wave_shape == SfxrGlobals.WAVE_SHAPES.NOISE):
|
|
for j in noise_buffer_length:
|
|
noise_buffer[i] = randf() * 2.0 - 1.0
|
|
|
|
# Base waveform
|
|
var fp: float = float(phase) / float(iperiod)
|
|
if (wave_shape == SfxrGlobals.WAVE_SHAPES.SQUARE):
|
|
if (fp < duty_cycle):
|
|
sub_sample = 0.5
|
|
else:
|
|
sub_sample = -0.5
|
|
elif (wave_shape == SfxrGlobals.WAVE_SHAPES.SAWTOOTH):
|
|
if (fp < duty_cycle):
|
|
sub_sample = -1.0 + 2.0 * fp / duty_cycle
|
|
else:
|
|
sub_sample = 1.0 - 2.0 * (fp - duty_cycle) / (1 - duty_cycle)
|
|
elif (wave_shape == SfxrGlobals.WAVE_SHAPES.SINE):
|
|
sub_sample = sin(fp * 2.0 * PI)
|
|
elif (wave_shape == SfxrGlobals.WAVE_SHAPES.NOISE):
|
|
sub_sample = noise_buffer[int(floor(phase * 32.0 / iperiod))]
|
|
else:
|
|
printerr("ERROR: Bad wave type: " + str(wave_shape))
|
|
sub_sample = 0
|
|
|
|
# Low-pass filter
|
|
var pp: float = fltp
|
|
fltw *= fltw_d
|
|
if (fltw > 0.1):
|
|
fltw = 0.1
|
|
elif (fltw < 0.0):
|
|
fltw = 0.0
|
|
if (enable_low_pass_filter):
|
|
fltdp += (sub_sample - fltp) * fltw
|
|
fltdp -= fltdp * fltdmp
|
|
else:
|
|
fltp = sub_sample
|
|
fltdp = 0.0
|
|
fltp += fltdp
|
|
|
|
# High-pass filter
|
|
fltphp += fltp - pp
|
|
fltphp -= fltphp * flthp
|
|
sub_sample = fltphp
|
|
|
|
# Flanger
|
|
flanger_buffer[ipp & 1023] = sub_sample
|
|
sub_sample += flanger_buffer[(ipp - iphase + 1024) & 1023]
|
|
|
|
ipp = (ipp + 1) & 1023
|
|
|
|
# Final accumulation and envelope application
|
|
sample += sub_sample * env_vol
|
|
|
|
# Accumulate samples appropriately for sample rate
|
|
sample_sum += sample
|
|
num_summed += 1.0
|
|
if (num_summed >= summands):
|
|
num_summed = 0.0
|
|
sample = sample_sum / summands
|
|
sample_sum = 0.0
|
|
else:
|
|
continue
|
|
|
|
sample = sample / SfxrGlobals.OVERSAMPLING * SfxrGlobals.MASTER_VOLUME
|
|
sample *= gain
|
|
|
|
sample = floor((sample + 1) * 128)
|
|
if (sample > 255):
|
|
sample = 255;
|
|
elif (sample < 0):
|
|
sample = 0
|
|
sample += 128
|
|
if sample > 255:
|
|
sample -= 255
|
|
|
|
_buffer.append(sample)
|
|
|
|
return _buffer
|
|
|
|
|
|
func build_sample(stream_player):
|
|
init_params(stream_player)
|
|
var sample: AudioStreamWAV = stream_player.stream
|
|
if (not sample):
|
|
stream_player.stream = AudioStreamWAV.new()
|
|
sample = stream_player.stream
|
|
sample.mix_rate = sample_rate
|
|
sample.data = PackedByteArray(get_raw_buffer())
|
|
return sample
|