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); }