980 lines
30 KiB
TypeScript
980 lines
30 KiB
TypeScript
import { Editor } from "./main";
|
|
import { scale } from './Scales';
|
|
import { tryEvaluate } from "./Evaluator";
|
|
import { MidiConnection } from "./IO/MidiConnection";
|
|
import { next } from "zifferjs";
|
|
import {
|
|
superdough,
|
|
samples,
|
|
initAudioOnFirstClick,
|
|
registerSynthSounds
|
|
} from 'superdough';
|
|
|
|
|
|
const init = Promise.all([
|
|
initAudioOnFirstClick(),
|
|
samples('github:tidalcycles/Dirt-Samples/master'),
|
|
registerSynthSounds(),
|
|
]);
|
|
|
|
|
|
|
|
class DrunkWalk {
|
|
|
|
/**
|
|
* A class that implements a "drunk walk" algorithm. This is useful for generating random
|
|
* numbers in a constrained range. The "drunk" starts at a position, and then makes a step
|
|
* of +1, 0, or -1. The "drunk" can be constrained to a range, and can wrap around the range.
|
|
*
|
|
* @param min - The minimum value of the range
|
|
* @param max - The maximum value of the range
|
|
* @param wrap - Whether or not the "drunk" should wrap around the range
|
|
* @param position - The starting/current position of the "drunk"
|
|
*/
|
|
|
|
public min: number;
|
|
public max: number;
|
|
private wrap: boolean;
|
|
public position: number;
|
|
|
|
constructor(min: number, max: number, wrap: boolean) {
|
|
this.min = min;
|
|
this.max = max;
|
|
this.wrap = wrap;
|
|
this.position = 0;
|
|
}
|
|
|
|
step(): void {
|
|
|
|
/**
|
|
* Makes a step in the "drunk walk" algorithm. This is a random step of +1, 0, or -1.
|
|
*/
|
|
|
|
const stepSize: number = Math.floor(Math.random() * 3) - 1;
|
|
this.position += stepSize;
|
|
|
|
if (this.wrap) {
|
|
if (this.position > this.max) {
|
|
this.position = this.min;
|
|
} else if (this.position < this.min) {
|
|
this.position = this.max;
|
|
}
|
|
} else {
|
|
if (this.position < this.min) {
|
|
this.position = this.min;
|
|
} else if (this.position > this.max) {
|
|
this.position = this.max;
|
|
}
|
|
}
|
|
}
|
|
|
|
getPosition(): number {
|
|
/**
|
|
* @returns The current position of the "drunk"
|
|
*/
|
|
return this.position;
|
|
}
|
|
|
|
toggleWrap(b: boolean): void {
|
|
/**
|
|
* Whether or not the "drunk" should wrap around the range
|
|
*
|
|
* @param b - Whether or not the "drunk" should wrap around the range
|
|
*/
|
|
this.wrap = b;
|
|
}
|
|
}
|
|
|
|
export class UserAPI {
|
|
|
|
/**
|
|
* The UserAPI class is the interface between the user's code and the backend. It provides
|
|
* access to the AudioContext, to the MIDI Interface, to internal variables, mouse position,
|
|
* useful functions, etc... This is the class that is exposed to the user's action and any
|
|
* function destined to the user should be placed here.
|
|
*/
|
|
|
|
private variables: { [key: string]: any } = {}
|
|
private iterators: { [key: string]: any } = {}
|
|
private _drunk: DrunkWalk = new DrunkWalk(-100, 100, false);
|
|
|
|
MidiConnection: MidiConnection = new MidiConnection()
|
|
load: samples
|
|
|
|
constructor (public app: Editor) {
|
|
this.load = samples("github:tidalcycles/Dirt-Samples/master");
|
|
}
|
|
|
|
// =============================================================
|
|
// Time functions
|
|
// =============================================================
|
|
|
|
get time(): number {
|
|
/**
|
|
* @returns The current time for the AudioContext
|
|
*/
|
|
return this.app.audioContext.currentTime
|
|
}
|
|
|
|
// =============================================================
|
|
// Mouse functions
|
|
// =============================================================
|
|
|
|
get mouseX(): number {
|
|
/**
|
|
* @returns The current x position of the mouse
|
|
*/
|
|
return this.app._mouseX
|
|
}
|
|
|
|
get mouseY(): number {
|
|
/**
|
|
* @returns The current y position of the mouse
|
|
*/
|
|
return this.app._mouseY
|
|
}
|
|
|
|
// =============================================================
|
|
// Utility functions
|
|
// =============================================================
|
|
|
|
log = console.log
|
|
|
|
scale = scale
|
|
|
|
rate(rate: number): void {
|
|
rate = rate;
|
|
// TODO: Implement this. This function should change the rate at which the global script
|
|
// is evaluated. This is useful for slowing down the script, or speeding it up. The default
|
|
// would be 1.0, which is the current rate (very speedy).
|
|
}
|
|
|
|
script(...args: number[]): void {
|
|
/**
|
|
* Evaluates 1-n local script(s)
|
|
*
|
|
* @param args - The scripts to evaluate
|
|
* @returns The result of the evaluation
|
|
*/
|
|
args.forEach(arg => {
|
|
tryEvaluate(
|
|
this.app,
|
|
this.app.universes[this.app.selected_universe].locals[arg],
|
|
)
|
|
})
|
|
}
|
|
s = this.script
|
|
|
|
clearscript(script: number): void {
|
|
/**
|
|
* Clears a local script
|
|
*
|
|
* @param script - The script to clear
|
|
*/
|
|
this.app.universes[this.app.selected_universe].locals[script] = {
|
|
candidate: '', committed: '', evaluations: 0
|
|
}
|
|
}
|
|
cs = this.clearscript
|
|
|
|
copyscript(from: number, to: number): void {
|
|
/**
|
|
* Copy from a local script to another local script
|
|
*
|
|
* @param from - The script to copy from
|
|
* @param to - The script to copy to
|
|
*/
|
|
this.app.universes[this.app.selected_universe].locals[to] =
|
|
this.app.universes[this.app.selected_universe].locals[from]
|
|
}
|
|
cps = this.copyscript
|
|
|
|
// =============================================================
|
|
// MIDI related functions
|
|
// =============================================================
|
|
|
|
public midi_outputs(): Array<MIDIOutput> {
|
|
/**
|
|
* Prints a list of available MIDI outputs in the console.
|
|
*
|
|
* @returns A list of available MIDI outputs
|
|
*/
|
|
console.log(this.MidiConnection.listMidiOutputs());
|
|
return this.MidiConnection.midiOutputs;
|
|
}
|
|
|
|
public midi_output(outputName: string): void {
|
|
/**
|
|
* Switches the MIDI output to the specified output.
|
|
*
|
|
* @param outputName - The name of the MIDI output to switch to
|
|
*/
|
|
if (!outputName) {
|
|
console.log(this.MidiConnection.getCurrentMidiPort())
|
|
} else {
|
|
this.MidiConnection.switchMidiOutput(outputName)
|
|
}
|
|
}
|
|
|
|
public note(note: number, channel: number = 0, velocity: number = 100, duration: number = 0.5): void {
|
|
/**
|
|
* Sends a MIDI note to the current MIDI output.
|
|
* TODO: Fix note duration
|
|
*
|
|
* @param note - The MIDI note to send
|
|
* @param channel - The MIDI channel to send the note on
|
|
* @param velocity - The velocity of the note
|
|
* @param duration - The duration of the note (in ms)
|
|
*
|
|
*/
|
|
this.MidiConnection.sendMidiNote(note, channel, velocity, duration)
|
|
}
|
|
|
|
public zn(input: string, options: {[key: string]: any} = {}): void {
|
|
const node = next(input, options);
|
|
const channel = options.channel ? options.channel : 0;
|
|
const velocity = options.velocity ? options.velocity : 100;
|
|
const sustain = options.sustain ? options.sustain : 0.5;
|
|
if(node.bend) this.MidiConnection.sendPitchBend(node.bend, channel);
|
|
this.MidiConnection.sendMidiNote(node.note!, channel, velocity, sustain);
|
|
if(node.bend) this.MidiConnection.sendPitchBend(8192, channel);
|
|
}
|
|
|
|
public sysex(data: Array<number>): void {
|
|
/**
|
|
* Sends a MIDI sysex message to the current MIDI output.
|
|
*
|
|
* @param data - The sysex data to send
|
|
*/
|
|
this.MidiConnection.sendSysExMessage(data)
|
|
}
|
|
|
|
public pitch_bend(value: number, channel: number): void {
|
|
/**
|
|
* Sends a MIDI pitch bend to the current MIDI output.
|
|
*
|
|
* @param value - The value of the pitch bend
|
|
* @param channel - The MIDI channel to send the pitch bend on
|
|
*
|
|
* @returns The value of the pitch bend
|
|
*/
|
|
this.MidiConnection.sendPitchBend(value, channel)
|
|
}
|
|
|
|
|
|
public program_change(program: number, channel: number): void {
|
|
/**
|
|
* Sends a MIDI program change to the current MIDI output.
|
|
*
|
|
* @param program - The MIDI program to send
|
|
* @param channel - The MIDI channel to send the program change on
|
|
*/
|
|
this.MidiConnection.sendProgramChange(program, channel)
|
|
}
|
|
|
|
public midi_clock(): void {
|
|
/**
|
|
* Sends a MIDI clock to the current MIDI output.
|
|
*/
|
|
this.MidiConnection.sendMidiClock()
|
|
}
|
|
|
|
public cc(control: number, value: number): void {
|
|
/**
|
|
* Sends a MIDI control change to the current MIDI output.
|
|
*
|
|
* @param control - The MIDI control to send
|
|
* @param value - The value of the control
|
|
*/
|
|
this.MidiConnection.sendMidiControlChange(control, value)
|
|
}
|
|
|
|
public midi_panic(): void {
|
|
/**
|
|
* Sends a MIDI panic message to the current MIDI output.
|
|
*/
|
|
this.MidiConnection.panic()
|
|
}
|
|
|
|
// =============================================================
|
|
// Iterator related functions
|
|
// =============================================================
|
|
|
|
public iterator(name: string, limit?: number, step?: number): number {
|
|
/**
|
|
* Returns the current value of an iterator, and increments it by the step value.
|
|
*
|
|
* @param name - The name of the iterator
|
|
* @param limit - The upper limit of the iterator
|
|
* @param step - The step value of the iterator
|
|
* @returns The current value of the iterator
|
|
*/
|
|
|
|
if (!(name in this.iterators)) {
|
|
// Create new iterator with default step of 1
|
|
this.iterators[name] = {
|
|
value: 0,
|
|
step: step ?? 1,
|
|
limit
|
|
};
|
|
} else {
|
|
// Check if limit has changed
|
|
if (this.iterators[name].limit !== limit) {
|
|
// Reset value to 0 and update limit
|
|
this.iterators[name].value = 0;
|
|
this.iterators[name].limit = limit;
|
|
}
|
|
|
|
// Check if step has changed
|
|
if (this.iterators[name].step !== step) {
|
|
// Update step
|
|
this.iterators[name].step = step ?? this.iterators[name].step;
|
|
}
|
|
|
|
// Increment existing iterator by step value
|
|
this.iterators[name].value += this.iterators[name].step;
|
|
|
|
// Check for limit overshoot
|
|
if (this.iterators[name].limit !== undefined &&
|
|
this.iterators[name].value > this.iterators[name].limit) {
|
|
this.iterators[name].value = 0;
|
|
}
|
|
}
|
|
|
|
// Return current iterator value
|
|
return this.iterators[name].value;
|
|
}
|
|
$ = this.iterator
|
|
|
|
// =============================================================
|
|
// Drunk mechanism
|
|
// =============================================================
|
|
|
|
get drunk() {
|
|
/**
|
|
*
|
|
* This function returns the current the drunk mechanism's
|
|
* current value.
|
|
*
|
|
* @returns The current position of the drunk mechanism
|
|
*/
|
|
this._drunk.step();
|
|
return this._drunk.getPosition();
|
|
}
|
|
|
|
set drunk(position: number) {
|
|
/**
|
|
* Sets the current position of the drunk mechanism.
|
|
*
|
|
* @param position - The value to set the drunk mechanism to
|
|
*/
|
|
this._drunk.position = position;
|
|
}
|
|
|
|
set drunk_max(max: number) {
|
|
/**
|
|
* Sets the maximum value of the drunk mechanism.
|
|
*
|
|
* @param max - The maximum value of the drunk mechanism
|
|
*/
|
|
this._drunk.max = max;
|
|
}
|
|
|
|
set drunk_min(min: number) {
|
|
/**
|
|
* Sets the minimum value of the drunk mechanism.
|
|
*
|
|
* @param min - The minimum value of the drunk mechanism
|
|
*/
|
|
this._drunk.min = min;
|
|
}
|
|
|
|
set drunk_wrap(wrap: boolean) {
|
|
/**
|
|
* Sets whether the drunk mechanism should wrap around
|
|
*
|
|
* @param wrap - Whether the drunk mechanism should wrap around
|
|
*/
|
|
this._drunk.toggleWrap(wrap);
|
|
}
|
|
|
|
// =============================================================
|
|
// Variable related functions
|
|
// =============================================================
|
|
|
|
public variable(a: number | string, b?: any): any {
|
|
/**
|
|
* Sets or returns the value of a variable internal to API.
|
|
*
|
|
* @param a - The name of the variable
|
|
* @param b - [optional] The value to set the variable to
|
|
* @returns The value of the variable
|
|
*/
|
|
if (typeof a === 'string' && b === undefined) {
|
|
return this.variables[a]
|
|
} else {
|
|
this.variables[a] = b
|
|
return this.variables[a]
|
|
}
|
|
}
|
|
v = this.variable
|
|
|
|
public delete_variable(name: string): void {
|
|
/**
|
|
* Deletes a variable internal to API.
|
|
*
|
|
* @param name - The name of the variable to delete
|
|
*/
|
|
delete this.variables[name]
|
|
}
|
|
dv = this.delete_variable
|
|
|
|
public clear_variables(): void {
|
|
/**
|
|
* Clears all variables internal to API.
|
|
*
|
|
* @remarks
|
|
* This function will delete all variables without warning.
|
|
* Use with caution.
|
|
*/
|
|
this.variables = {}
|
|
}
|
|
cv = this.clear_variables
|
|
|
|
// =============================================================
|
|
// Small algorithmic functions
|
|
// =============================================================
|
|
|
|
pick<T>(...array: T[]): T {
|
|
/**
|
|
* Returns a random element from an array.
|
|
*
|
|
* @param array - The array of values to pick from
|
|
*/
|
|
return array[Math.floor(Math.random() * array.length)]
|
|
}
|
|
|
|
seqbeat<T>(...array: T[]): T {
|
|
/**
|
|
* Returns an element from an array based on the current beat.
|
|
*
|
|
* @param array - The array of values to pick from
|
|
*/
|
|
return array[this.app.clock.time_position.beat % array.length]
|
|
}
|
|
|
|
mel<T>(iterator: number, array: T[]): T {
|
|
/**
|
|
* Returns an element from an array based on the current value of an iterator.
|
|
*
|
|
* @param iterator - The name of the iterator
|
|
* @param array - The array of values to pick from
|
|
*/
|
|
return array[iterator % array.length]
|
|
}
|
|
|
|
seqbar<T>(...array: T[]): T {
|
|
/**
|
|
* Returns an element from an array based on the current bar.
|
|
*
|
|
* @param array - The array of values to pick from
|
|
*/
|
|
return array[this.app.clock.time_position.bar % array.length]
|
|
}
|
|
|
|
seqpulse<T>(...array: T[]): T {
|
|
/**
|
|
* Returns an element from an array based on the current pulse.
|
|
*
|
|
* @param array - The array of values to pick from
|
|
*/
|
|
return array[this.app.clock.time_position.pulse % array.length]
|
|
}
|
|
|
|
// =============================================================
|
|
// Randomness functions
|
|
// =============================================================
|
|
|
|
randI(min: number, max: number): number {
|
|
/**
|
|
* Returns a random integer between min and max.
|
|
*
|
|
* @param min - The minimum value of the random number
|
|
* @param max - The maximum value of the random number
|
|
* @returns A random integer between min and max
|
|
*/
|
|
return Math.floor(Math.random() * (max - min + 1)) + min
|
|
}
|
|
|
|
rand(min: number, max: number): number {
|
|
/**
|
|
* Returns a random float between min and max.
|
|
*
|
|
* @param min - The minimum value of the random number
|
|
* @param max - The maximum value of the random number
|
|
* @returns A random float between min and max
|
|
*/
|
|
return Math.random() * (max - min) + min
|
|
}
|
|
rI = this.randI; r = this.rand
|
|
|
|
// =============================================================
|
|
// Quantification functions
|
|
// =============================================================
|
|
|
|
public quantize(value: number, quantization: number[]): number {
|
|
/**
|
|
* Returns the closest value in an array to a given value.
|
|
*
|
|
* @param value - The value to quantize
|
|
* @param quantization - The array of values to quantize to
|
|
* @returns The closest value in the array to the given value
|
|
*/
|
|
if (quantization.length === 0) { return value }
|
|
let closest = quantization[0]
|
|
quantization.forEach(q => {
|
|
if (Math.abs(q - value) < Math.abs(closest - value)) { closest = q }
|
|
})
|
|
return closest
|
|
}
|
|
quant = this.quantize
|
|
|
|
public clamp(value: number, min: number, max: number): number {
|
|
/**
|
|
* Returns a value clamped between min and max.
|
|
*
|
|
* @param value - The value to clamp
|
|
* @param min - The minimum value of the clamped value
|
|
* @param max - The maximum value of the clamped value
|
|
* @returns A value clamped between min and max
|
|
*/
|
|
return Math.min(Math.max(value, min), max)
|
|
}
|
|
cmp = this.clamp
|
|
|
|
// =============================================================
|
|
// Transport functions
|
|
// =============================================================
|
|
|
|
bpm(bpm?: number): number {
|
|
/**
|
|
* Sets or returns the current bpm.
|
|
*
|
|
* @param bpm - [optional] The bpm to set
|
|
* @returns The current bpm
|
|
*/
|
|
if (bpm === undefined)
|
|
return this.app.clock.bpm
|
|
|
|
if (bpm < 1 || bpm > 500)
|
|
console.log(`Setting bpm to ${bpm}`)
|
|
this.app.clock.bpm = bpm
|
|
return bpm
|
|
}
|
|
tempo = this.bpm
|
|
|
|
time_signature(numerator: number, denominator: number): void {
|
|
/**
|
|
* Sets the time signature.
|
|
*
|
|
* @param numerator - The numerator of the time signature
|
|
* @param denominator - The denominator of the time signature
|
|
* @returns The current time signature
|
|
*/
|
|
this.app.clock.time_signature = [numerator, denominator]
|
|
}
|
|
|
|
// =============================================================
|
|
// Probability functions
|
|
// =============================================================
|
|
|
|
public almostNever():boolean {
|
|
/**
|
|
* Returns true 10% of the time.
|
|
*
|
|
* @returns True 10% of the time
|
|
*/
|
|
return Math.random() > 0.9
|
|
}
|
|
|
|
public sometimes(): boolean {
|
|
/**
|
|
* Returns true 50% of the time.
|
|
*
|
|
* @returns True 50% of the time
|
|
*/
|
|
return Math.random() > 0.5
|
|
}
|
|
|
|
public rarely():boolean {
|
|
/**
|
|
* Returns true 25% of the time.
|
|
*
|
|
* @returns True 25% of the time
|
|
*/
|
|
return Math.random() > 0.75
|
|
}
|
|
|
|
public often(): boolean {
|
|
/**
|
|
* Returns true 75% of the time.
|
|
*
|
|
* @returns True 75% of the time
|
|
*/
|
|
return Math.random() > 0.25
|
|
}
|
|
|
|
public almostAlways():boolean {
|
|
/**
|
|
* Returns true 90% of the time.
|
|
*
|
|
* @returns True 90% of the time
|
|
*/
|
|
return Math.random() > 0.1
|
|
}
|
|
|
|
public dice(sides: number):number {
|
|
/**
|
|
* Returns the value of a dice roll with n sides.
|
|
*
|
|
* @param sides - The number of sides on the dice
|
|
* @returns The value of a dice roll with n sides
|
|
*/
|
|
return Math.floor(Math.random() * sides) + 1
|
|
}
|
|
|
|
// =============================================================
|
|
// Iterator functions (for loops, with evaluation count, etc...)
|
|
// =============================================================
|
|
|
|
get i() {
|
|
/**
|
|
* Returns the current iteration of global file.
|
|
*
|
|
* @returns The current iteration of global file
|
|
*/
|
|
return this.app.universes[this.app.selected_universe].global.evaluations
|
|
}
|
|
|
|
// =============================================================
|
|
// Time markers
|
|
// =============================================================
|
|
|
|
get bar(): number {
|
|
/**
|
|
* Returns the current bar number
|
|
*
|
|
* @returns The current bar number
|
|
*/
|
|
return this.app.clock.time_position.bar
|
|
}
|
|
|
|
get tick(): number {
|
|
/**
|
|
* Returns the current tick number
|
|
*
|
|
* @returns The current tick number
|
|
*/
|
|
return this.app.clock.tick
|
|
}
|
|
|
|
get pulse(): number {
|
|
/**
|
|
* Returns the current pulse number
|
|
*
|
|
* @returns The current pulse number
|
|
*/
|
|
return this.app.clock.time_position.pulse
|
|
}
|
|
|
|
get beat(): number {
|
|
/**
|
|
* Returns the current beat number
|
|
*
|
|
* @returns The current beat number
|
|
*/
|
|
return this.app.clock.time_position.beat
|
|
}
|
|
|
|
get t_beat(): number {
|
|
/**
|
|
* Returns the current beat number since the origin of time
|
|
* TODO: fix! Why is this not working?
|
|
*/
|
|
return Math.floor(this.app.clock.tick / this.app.clock.ppqn)
|
|
}
|
|
|
|
|
|
onbar(n: number, ...bar: number[]): boolean {
|
|
// n is acting as a modulo on the bar number
|
|
const bar_list = [...Array(n).keys()].map(i => i + 1);
|
|
console.log(bar.some(b => bar_list.includes(b % n)))
|
|
return bar.some(b => bar_list.includes(b % n))
|
|
}
|
|
|
|
onbeat(...beat: number[]): boolean {
|
|
/**
|
|
* Returns true if the current beat is in the given list of beats.
|
|
*
|
|
* @remarks
|
|
* This function can also operate with decimal beats!
|
|
*
|
|
* @param beat - The beats to check
|
|
* @returns True if the current beat is in the given list of beats
|
|
*/
|
|
let final_pulses: boolean[] = []
|
|
beat.forEach(b => {
|
|
b = 1 + (b % this.app.clock.time_signature[0])
|
|
let integral_part = Math.floor(b);
|
|
let decimal_part = b - integral_part;
|
|
final_pulses.push(
|
|
integral_part === this.app.clock.time_position.beat &&
|
|
this.app.clock.time_position.pulse === decimal_part * this.app.clock.ppqn
|
|
)
|
|
});
|
|
return final_pulses.some(p => p == true)
|
|
}
|
|
|
|
stop(): void {
|
|
/**
|
|
* Stops the clock.
|
|
*
|
|
* @see silence
|
|
* @see hush
|
|
*/
|
|
this.app.clock.pause()
|
|
this.app.setButtonHighlighting("pause", true);
|
|
}
|
|
silence = this.stop
|
|
hush = this.stop
|
|
|
|
prob(p: number): boolean {
|
|
/**
|
|
* Returns true p% of the time.
|
|
*
|
|
* @param p - The probability of returning true
|
|
* @returns True p% of the time
|
|
*/
|
|
return Math.random() * 100 < p
|
|
}
|
|
|
|
toss(): boolean {
|
|
/**
|
|
* Returns true 50% of the time.
|
|
*
|
|
* @returns True 50% of the time
|
|
* @see sometimes
|
|
* @see rarely
|
|
* @see often
|
|
* @see almostAlways
|
|
* @see almostNever
|
|
*/
|
|
return Math.random() > 0.5
|
|
}
|
|
|
|
min(...values: number[]): number {
|
|
/**
|
|
* Returns the minimum value of a list of numbers.
|
|
*
|
|
* @param values - The list of numbers
|
|
* @returns The minimum value of the list of numbers
|
|
*/
|
|
return Math.min(...values)
|
|
}
|
|
|
|
max(...values: number[]): number {
|
|
/**
|
|
* Returns the maximum value of a list of numbers.
|
|
*
|
|
* @param values - The list of numbers
|
|
* @returns The maximum value of the list of numbers
|
|
*/
|
|
return Math.max(...values)
|
|
}
|
|
|
|
limit(value: number, min: number, max: number): number {
|
|
/**
|
|
* Limits a value between a minimum and a maximum.
|
|
*
|
|
* @param value - The value to limit
|
|
* @param min - The minimum value
|
|
* @param max - The maximum value
|
|
* @returns The limited value
|
|
*/
|
|
return Math.min(Math.max(value, min), max)
|
|
}
|
|
|
|
|
|
delay(ms: number, func: Function): void {
|
|
/**
|
|
* Delays the execution of a function by a given number of milliseconds.
|
|
*
|
|
* @param ms - The number of milliseconds to delay the function by
|
|
* @param func - The function to execute
|
|
* @returns The current time signature
|
|
*/
|
|
setTimeout(func, ms)
|
|
}
|
|
|
|
delayr(ms: number, nb: number, func: Function): void {
|
|
/**
|
|
* Delays the execution of a function by a given number of milliseconds, repeated a given number of times.
|
|
*
|
|
* @param ms - The number of milliseconds to delay the function by
|
|
* @param nb - The number of times to repeat the delay
|
|
* @param func - The function to execute
|
|
* @returns The current time signature
|
|
*/
|
|
const list = [...Array(nb).keys()].map(i => ms * i);
|
|
list.forEach((ms, _) => {
|
|
setTimeout(func, ms)
|
|
});
|
|
}
|
|
|
|
mod(...pulse: number[]): boolean {
|
|
/**
|
|
* Returns true if the current pulse is a modulo of any of the given pulses.
|
|
*
|
|
* @param pulse - The pulse to check for
|
|
* @returns True if the current pulse is a modulo of any of the given pulses
|
|
*/
|
|
return pulse.some(p => this.app.clock.time_position.pulse % p === 0)
|
|
}
|
|
|
|
modbar(...bar: number[]): boolean {
|
|
/**
|
|
* Returns true if the current bar is a modulo of any of the given bars.
|
|
*
|
|
* @param bar - The bar to check for
|
|
* @returns True if the current bar is a modulo of any of the given bars
|
|
*
|
|
*/
|
|
return bar.some(b => this.app.clock.time_position.bar % b === 0)
|
|
}
|
|
|
|
euclid(iterator: number, pulses: number, length: number, rotate: number=0): boolean {
|
|
/**
|
|
* Returns a euclidean cycle of size length, with n pulses, rotated or not.
|
|
*
|
|
* @param iterator - Iteration number in the euclidian cycle
|
|
* @param pulses - The number of pulses in the cycle
|
|
* @param length - The length of the cycle
|
|
* @param rotate - Rotation of the euclidian sequence
|
|
* @returns boolean value based on the euclidian sequence
|
|
*/
|
|
return this._euclidean_cycle(pulses, length, rotate)[iterator % length];
|
|
}
|
|
|
|
_euclidean_cycle(pulses: number, length: number, rotate: number = 0): boolean[] {
|
|
function startsDescent(list: number[], i: number): boolean {
|
|
const length = list.length;
|
|
const nextIndex = (i + 1) % length;
|
|
return list[i] > list[nextIndex] ? true : false;
|
|
}
|
|
if (pulses >= length) return [true];
|
|
const resList = Array.from({length}, (_, i) => ((pulses * (i - 1)) % length + length) % length);
|
|
let cycle = resList.map((_, i) => startsDescent(resList, i));
|
|
if(rotate!=0) {
|
|
cycle = cycle.slice(rotate).concat(cycle.slice(0, rotate));
|
|
}
|
|
return cycle;
|
|
}
|
|
|
|
bin(iterator: number, n: number): boolean {
|
|
/**
|
|
* Returns a binary cycle of size n.
|
|
*
|
|
* @param iterator - Iteration number in the binary cycle
|
|
* @param n - The number to convert to binary
|
|
* @returns boolean value based on the binary sequence
|
|
*/
|
|
let convert: string = n.toString(2);
|
|
let tobin: boolean[] = convert.split("").map((x: string) => x === "1");
|
|
return tobin[iterator % tobin.length];
|
|
}
|
|
|
|
// =============================================================
|
|
// Low Frequency Oscillators
|
|
// =============================================================
|
|
|
|
sine(freq: number = 1, offset: number=0): number {
|
|
/**
|
|
* Returns a sine wave between -1 and 1.
|
|
*
|
|
* @param freq - The frequency of the sine wave
|
|
* @param offset - The offset of the sine wave
|
|
* @returns A sine wave between -1 and 1
|
|
*/
|
|
return Math.sin(this.app.clock.ctx.currentTime * Math.PI * 2 * freq) + offset
|
|
}
|
|
|
|
saw(freq: number = 1, offset: number=0): number {
|
|
/**
|
|
* Returns a saw wave between -1 and 1.
|
|
*
|
|
* @param freq - The frequency of the saw wave
|
|
* @param offset - The offset of the saw wave
|
|
* @returns A saw wave between -1 and 1
|
|
* @see triangle
|
|
* @see square
|
|
* @see sine
|
|
* @see noise
|
|
*/
|
|
return (this.app.clock.ctx.currentTime * freq) % 1 * 2 - 1 + offset
|
|
}
|
|
|
|
triangle(freq: number = 1, offset: number=0): number {
|
|
/**
|
|
* Returns a triangle wave between -1 and 1.
|
|
*
|
|
* @returns A triangle wave between -1 and 1
|
|
* @see saw
|
|
* @see square
|
|
* @see sine
|
|
* @see noise
|
|
*/
|
|
return Math.abs(this.saw(freq, offset)) * 2 - 1
|
|
}
|
|
|
|
square(freq: number = 1, offset: number=0): number {
|
|
/**
|
|
* Returns a square wave between -1 and 1.
|
|
*
|
|
* @returns A square wave between -1 and 1
|
|
* @see saw
|
|
* @see triangle
|
|
* @see sine
|
|
* @see noise
|
|
*/
|
|
return this.saw(freq, offset) > 0 ? 1 : -1
|
|
}
|
|
|
|
noise(): number {
|
|
/**
|
|
* Returns a random value between -1 and 1.
|
|
*
|
|
* @returns A random value between -1 and 1
|
|
* @see saw
|
|
* @see triangle
|
|
* @see square
|
|
* @see sine
|
|
* @see noise
|
|
*/
|
|
return Math.random() * 2 - 1
|
|
}
|
|
|
|
// =============================================================
|
|
// Math functions
|
|
// =============================================================
|
|
|
|
abs = Math.abs
|
|
|
|
// =============================================================
|
|
// Trivial functions
|
|
// =============================================================
|
|
|
|
sound = async (values: object, delay: number = 0.00) => {
|
|
superdough(values, delay)
|
|
}
|
|
}
|