void NextBeat(float[] jacks)
{
beatIndex++;
if (!notes.IsEmpty)
{
var note = notes.Peek();
if (note.beat <= beatIndex)
{
position = 0;
outputTrigger.Value(jacks, 1);
activeNote = notes.Pop();
var tr = (int)transpose.Value(jacks);
if (tr != 0 && activeNote.noteNumber >= 0)
{
activeNote.hz = Note.Frequency(activeNote.noteNumber + tr);
}
activeNote.hz *= frequencyMultiply.Value(jacks);
if (notes.IsEmpty)
{
ChangeNoteTriggerPattern();
ScheduleNoteTriggers(beatIndex + activeNote.duration);
}
nextNote = notes.Peek();
if (tr != 0 && nextNote.noteNumber >= 0)
{
nextNote.hz = Note.Frequency(nextNote.noteNumber + tr);
}
nextNote.hz *= frequencyMultiply.Value(jacks);
}
}
}
protected override float GetSample(float[] jacks)
{
var freq = frequency.Value(jacks);
if (Mathf.Approximately(freq, 0))
{
return(0);
}
var periodF = (Osc.SAMPLERATE / (Mathf.Epsilon + frequency.Value(jacks)));
period = (int)periodF;
var frac = periodF - period;
var si = sampleIndex % period;
if (si == 0)
{
loopCount++;
}
var smp = 0f;
if (sampleIndex < period)
{
smp = (Entropy.Next() * 2) - 1;
wave[activeString, si] += smp;
}
var doFilter = sampleIndex > period;
for (var i = 0; i < 6; i++)
{
if (!(doFilter && activeString == i))
{
var prev = (si > 0 ? wave[i, si - 1] : 0);
var mustFilter = sampleIndex < (period * minDecayCycles.Value(jacks));
var mightFilter = false;
if (mustFilter)
{
mightFilter = (Entropy.Next() <= (1f / decayProbability.Value(jacks)));
}
if (mustFilter || mightFilter)
{
wave[i, si] = (prev + wave[i, si]) * 0.5f;
}
smp += Lerp(wave[i, si], wave[i, (si + 1) % (period + 1)], frac);
}
}
return(smp);
}
public float Sample(float[] jacks, int sample)
{
if (sequence == null || lastCode != code || lastType != type)
{
Parse();
ScheduleNoteTriggers(0);
}
position++;
var gateValue = gate.Value(jacks);
outputTrigger.Value(jacks, -1);
if (gateValue > 0 && lastGate < 0)
{
beatDuration = (sample - lastBeat);
lastBeat = sample;
NextBeat(jacks);
}
var hz = activeNote.hz;
var N = position * 1f / (beatDuration * activeNote.duration);
var glideStart = (1f - glide.Value(jacks));
if (N >= glideStart)
{
hz = Mathf.SmoothStep(activeNote.hz, nextNote.hz, Mathf.InverseLerp(glideStart, 1, N));
}
lastGate = gateValue;
output.Value(jacks, hz);
var e = beatDuration > 0 ? envelope.Evaluate(N) : 1;
outputEnvelope.Value(jacks, activeNote.volume * e);
return(activeNote.hz);
}
public virtual float Sample(float[] jacks, int t)
{
var gateValue = gate.Value(jacks);
if (gateValue > 0 && lastGate < 0)
{
position = 0;
sampleIndex = 0;
OnGate();
}
else
{
position += (1f / Osc.SAMPLERATE);
sampleIndex++;
}
lastGate = gateValue;
var smp = GetSample(jacks);
if (multiply.connectedId != 0)
{
smp *= multiply.Value(jacks);
}
if (add.connectedId != 0)
{
smp += add.Value(jacks);
}
smp = bias.Value(jacks) + (smp * gain.Value(jacks));
output.Value(jacks, smp);
return(smp);
}
public float Sample(float[] jacks, int t)
{
var smp = 0f;
if (inputA.connectedId != 0)
{
smp += inputA.Value(jacks) * gainA.Value(jacks);
}
if (inputB.connectedId != 0)
{
smp += inputB.Value(jacks) * gainB.Value(jacks);
}
if (inputC.connectedId != 0)
{
smp += inputC.Value(jacks) * gainC.Value(jacks);
}
if (inputD.connectedId != 0)
{
smp += inputD.Value(jacks) * gainD.Value(jacks);
}
if (multiply.connectedId != 0)
{
smp *= multiply.Value(jacks);
}
if (add.connectedId != 0)
{
smp += add.Value(jacks);
}
smp = bias.Value(jacks) + (smp * gain.Value(jacks));
output.Value(jacks, smp);
return(smp);
}
public virtual float Sample(float[] jacks, int t)
{
if (!isReady)
{
return(0);
}
var smp = 0f;
if (superSample)
{
var s = (1f / SAMPLERATE) / 8;
var p = ph;
for (var i = 0; i < 8; i++)
{
smp += _Sample(jacks, p);
p += s;
if (p > TWOPI)
{
p -= TWOPI;
}
}
smp /= 8;
}
else
{
smp = _Sample(jacks, phase);
}
if (bandlimited)
{
smp = BandLimit(smp);
}
if (multiply.connectedId != 0)
{
smp *= multiply.Value(jacks);
}
if (add.connectedId != 0)
{
smp += add.Value(jacks);
}
ph = phase;
phase = phase + ((TWOPI * (frequency.Value(jacks) + detune.Value(jacks))) / SAMPLERATE);
if (phase > TWOPI)
{
phase -= TWOPI;
}
smp = bias.Value(jacks) + (smp * RampedGain(jacks, gain));
output.Value((jacks), smp);
return(smp);
}
public float Sample(float[] jacks, int t)
{
if (input.connectedId == 0)
{
output.Value(jacks, 0);
return(0);
}
var bufferLength = buffer.Length;
var timeTarget = delay.Value(jacks) * Osc.SAMPLERATE;
time = 0.0001f * timeTarget + 0.9999f * time;
var samples = (int)time;
var frac = time - samples;
var pastIndex = index - samples;
while (pastIndex < 0)
{
pastIndex = bufferLength + pastIndex;
}
var A = buffer[pastIndex];
var B = buffer[(pastIndex + 1) % bufferLength];
var smp = (B - A) * frac + A;
var inp = input.Value(jacks);
buffer[index] = inp + (smp * feedback.Value(jacks));
index++;
if (index >= bufferLength)
{
index -= bufferLength;
}
if (multiply.connectedId != 0)
{
smp *= multiply.Value(jacks);
}
if (add.connectedId != 0)
{
smp += add.Value(jacks);
}
smp = bias.Value(jacks) + (smp * gain.Value(jacks));
output.Value(jacks, smp);
return(smp);
}
public float Sample(float[] jacks, int t)
{
if (input.connectedId == 0)
{
output.Value(jacks, 0);
return 0;
}
var smp = _Update(jacks, input.Value(jacks));
if (multiply.connectedId != 0)
smp *= multiply.Value(jacks);
if (add.connectedId != 0)
smp += add.Value(jacks);
smp = bias.Value(jacks) + (smp * gain.Value(jacks));
output.Value(jacks, smp);
return smp;
}
protected float _Sample(float[] jacks, float phase)
{
switch (type)
{
case OscType.Sin:
return(Mathf.Sin(phase));
case OscType.WaveShape:
return(shape.Evaluate(phase / TWOPI));
case OscType.Square:
return(phase < Mathf.PI ? 1f : -1f);
case OscType.PWM:
return(phase < Mathf.PI * duty.Value(jacks) ? 1f : -1f);
case OscType.Tan:
return(Mathf.Clamp(Mathf.Tan(phase / 2), -1, 1));
case OscType.Saw:
return(1f - (1f / Mathf.PI * phase));
case OscType.Triangle:
if (phase < Mathf.PI)
{
return(-1f + (2 * 1f / Mathf.PI) * phase);
}
else
{
return(3f - (2 * 1f / Mathf.PI) * phase);
}
case OscType.Noise:
return(noiseBuffer[(noiseIndex++) % noiseBuffer.Length]);
default:
return(0);
}
}
float _Update(float[] jacks, float smp)
{
var c = cutoff.Value(jacks);
var r = q.Value(jacks);
switch (type)
{
case FilterType.Lowpass:
bqFilter.SetLowPass(c, r);
break;
case FilterType.Highpass:
bqFilter.SetHighPass(c, r);
break;
case FilterType.Bandpass:
bqFilter.SetBandPass(c, r);
break;
case FilterType.Bandstop:
bqFilter.SetBandStop(c, r);
break;
case FilterType.Allpass:
bqFilter.SetAllPass(c, r);
break;
}
switch (type)
{
case FilterType.PassThru: return smp;
case FilterType.Lowpass:
case FilterType.Highpass:
case FilterType.Bandpass:
case FilterType.Bandstop:
case FilterType.Allpass:
return bqFilter.Update(smp);
case FilterType.Waveshaper:
return waveshaper.Evaluate(smp);
}
return 0f;
}
public float Sample(float[] jacks, int t)
{
var smp = 0f;
var apos = ramp.Evaluate(position.Value(jacks));
var fpos = (apos * 8) % 8;
var ipos = (int)(fpos);
var frac = fpos - ipos;
var omf = 1f - frac;
if (quant)
{
omf = 1;
frac = 0;
}
output.Value(jacks, inputA.Value(jacks));
smp += inputA.Value(jacks) * (ipos == 0 ? omf : ipos == 7 ? frac : 0);
smp += inputB.Value(jacks) * (ipos == 1 ? omf : ipos == 0 ? frac : 0);
smp += inputC.Value(jacks) * (ipos == 2 ? omf : ipos == 1 ? frac : 0);
smp += inputD.Value(jacks) * (ipos == 3 ? omf : ipos == 2 ? frac : 0);
smp += inputE.Value(jacks) * (ipos == 4 ? omf : ipos == 3 ? frac : 0);
smp += inputF.Value(jacks) * (ipos == 5 ? omf : ipos == 4 ? frac : 0);
smp += inputG.Value(jacks) * (ipos == 6 ? omf : ipos == 5 ? frac : 0);
smp += inputH.Value(jacks) * (ipos == 7 ? omf : ipos == 6 ? frac : 0);
if (multiply.connectedId != 0)
{
smp *= multiply.Value(jacks);
}
if (add.connectedId != 0)
{
smp += add.Value(jacks);
}
smp *= gain.Value(jacks);
output.Value(jacks, smp);
return(smp);
}
protected float RampedGain(float[] jacks, JackIn j)
{
_gain = Lerp(_gain, j.Value(jacks), 0.01f);
return(_gain);
}
