mirror of
https://codeberg.org/uzu/strudel
synced 2026-10-12 19:42:47 -04:00
Compare commits
2 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| 8722c94bbe | |||
| b606bf4692 |
@@ -13,12 +13,16 @@ jobs:
|
||||
build:
|
||||
if: ${{ github.event.label.name == 'serve-hot' }}
|
||||
runs-on: docker
|
||||
container: node:22-bookworm
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
ref: ${{ github.event.pull_request.head.sha }}
|
||||
ref: ${{ github.event.pull_request.head.sha }}
|
||||
- uses: pnpm/action-setup@v4
|
||||
with:
|
||||
version: 9.12.2
|
||||
- uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: 20
|
||||
|
||||
- name: Install Dependencies
|
||||
run: pnpm install
|
||||
@@ -37,4 +41,4 @@ jobs:
|
||||
ssh-keyscan matrix.toplap.org > ~/.ssh/known_hosts
|
||||
rsync -atv --delete --delete-after --progress \
|
||||
./website/dist/ \
|
||||
strudel@matrix.toplap.org:/home/strudel/deploy/pr-${{ github.event.pull_request.number }}.hot.strudel.cc
|
||||
strudel@matrix.toplap.org:/home/strudel/deploy/pr-${{ github.event.pull_request.number }}.hot.strudel.cc
|
||||
@@ -13,13 +13,17 @@ concurrency:
|
||||
jobs:
|
||||
build:
|
||||
runs-on: docker
|
||||
container: node:22-bookworm
|
||||
env:
|
||||
SSH_PRIVATE_KEY: ${{ secrets.SSH_PRIVATE_KEY }}
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: pnpm/action-setup@v4
|
||||
|
||||
with:
|
||||
version: 9.12.2
|
||||
- uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: 20
|
||||
# cache: "pnpm"
|
||||
- name: Install Dependencies
|
||||
run: pnpm install
|
||||
|
||||
@@ -33,4 +37,4 @@ jobs:
|
||||
apt update && apt install -y rsync
|
||||
mkdir ~/.ssh
|
||||
ssh-keyscan matrix.toplap.org > ~/.ssh/known_hosts
|
||||
rsync -atv --delete --delete-after --progress ./website/dist/ strudel@matrix.toplap.org:/home/strudel/deploy/strudel.cc
|
||||
rsync -atv --delete --delete-after --progress ./website/dist/ strudel@matrix.toplap.org:/home/strudel/deploy/strudel.cc
|
||||
@@ -10,13 +10,17 @@ concurrency:
|
||||
jobs:
|
||||
build:
|
||||
runs-on: docker
|
||||
container: node:22-bookworm
|
||||
env:
|
||||
SSH_PRIVATE_KEY: ${{ secrets.SSH_PRIVATE_KEY }}
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: pnpm/action-setup@v4
|
||||
|
||||
with:
|
||||
version: 9.12.2
|
||||
- uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: 20
|
||||
# cache: "pnpm"
|
||||
- name: Install Dependencies
|
||||
run: pnpm install
|
||||
|
||||
@@ -30,4 +34,4 @@ jobs:
|
||||
apt update && apt install -y rsync
|
||||
mkdir ~/.ssh
|
||||
ssh-keyscan matrix.toplap.org > ~/.ssh/known_hosts
|
||||
rsync -atv --delete --delete-after --progress ./website/dist/ strudel@matrix.toplap.org:/home/strudel/deploy/cold.strudel.cc
|
||||
rsync -atv --delete --delete-after --progress ./website/dist/ strudel@matrix.toplap.org:/home/strudel/deploy/cold.strudel.cc
|
||||
@@ -5,11 +5,21 @@ on: [push, pull_request]
|
||||
jobs:
|
||||
build:
|
||||
runs-on: docker
|
||||
container: node:22-bookworm
|
||||
strategy:
|
||||
matrix:
|
||||
node-version: [20]
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: apt install ztd
|
||||
run: apt update && apt install -y zstd
|
||||
- uses: pnpm/action-setup@v4
|
||||
with:
|
||||
version: 9.12.2
|
||||
- uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: ${{ matrix.node-version }}
|
||||
cache: "pnpm"
|
||||
- run: pnpm install
|
||||
- run: pnpm run format-check
|
||||
- run: pnpm run lint
|
||||
|
||||
+1
-11
@@ -52,17 +52,7 @@ Strudel is a project handmade by humans, with thought and nuance.
|
||||
|
||||
If you have used LLMs (so called 'AI'), please detail that in the pull request. We are still developing our response to the onslaught of LLM technology, but for practical and legal reasons are currently not accepting wholly LLM-generated code. We are also not accepting PRs that add LLM features to strudel itself.
|
||||
|
||||
There are #llm-chat and #llm-share channels on [our discord](https://discord.com/invite/HGEdXmRkzT). Please do not discuss or share LLM-related things outside of those channels.
|
||||
|
||||
## Creating and sharing a new project using strudel
|
||||
|
||||
Strudel is free/open source software, and we are also happy to see people making use of it within the following terms.
|
||||
|
||||
Please don't use 'strudel' in the name of your project, so people don't assume it's official strudel project. (If you'd like it to be an official strudel project, please check in with the community, e.g. on [the discord](https://discord.com/invite/HGEdXmRkzT).)
|
||||
|
||||
Please respect our AGPL license, which e.g. requires you to share/link to the source code of strudel, any modifications you've made to it, and the source code for the rest of your project if it integrates with strudel. You are also required to maintain Strudel's copyright notices in the source code, and include Strudel's copyright notice in your user interface. This is an ad-hoc summary - please [refer to the license](https://codeberg.org/uzu/strudel/src/branch/main/LICENSE) for full details.
|
||||
|
||||
You are also encouraged to connect with the community and understand our aims and values.
|
||||
There are #llm-chat and #llm-share channels on our discord. Please do not discuss or share LLM-related things outside of those channels.
|
||||
|
||||
## Report a Bug
|
||||
|
||||
|
||||
@@ -16,7 +16,7 @@ const drawContext = canvas.getContext('2d');
|
||||
const drawTime = [-2, 2]; // time window of drawn haps
|
||||
|
||||
const editor = new StrudelMirror({
|
||||
onSchedule: webaudioOutput,
|
||||
defaultOutput: webaudioOutput,
|
||||
getTime: () => getAudioContext().currentTime,
|
||||
transpiler,
|
||||
root: document.getElementById('editor'),
|
||||
|
||||
@@ -12,7 +12,7 @@ registerSynthSounds();
|
||||
evalScope(import('@strudel/core'), import('@strudel/mini'), import('@strudel/webaudio'), import('@strudel/tonal'));
|
||||
|
||||
const { evaluate } = repl({
|
||||
onSchedule: webaudioOutput,
|
||||
defaultOutput: webaudioOutput,
|
||||
getTime: () => ctx.currentTime,
|
||||
transpiler,
|
||||
});
|
||||
|
||||
@@ -3,7 +3,6 @@
|
||||
"version": "0.5.0",
|
||||
"private": true,
|
||||
"description": "Port of tidalcycles to javascript",
|
||||
"packageManager": "pnpm@10.15.0",
|
||||
"scripts": {
|
||||
"setup": "pnpm i",
|
||||
"pretest": "npm run jsdoc-json",
|
||||
|
||||
@@ -2,13 +2,23 @@ import {
|
||||
keymap,
|
||||
highlightSpecialChars,
|
||||
drawSelection,
|
||||
highlightActiveLine,
|
||||
dropCursor,
|
||||
rectangularSelection,
|
||||
crosshairCursor,
|
||||
lineNumbers,
|
||||
highlightActiveLineGutter,
|
||||
} from '@codemirror/view';
|
||||
import { defaultHighlightStyle, syntaxHighlighting } from '@codemirror/language';
|
||||
import {
|
||||
defaultHighlightStyle,
|
||||
syntaxHighlighting,
|
||||
bracketMatching,
|
||||
foldGutter,
|
||||
foldKeymap,
|
||||
} from '@codemirror/language';
|
||||
import { defaultKeymap, history, historyKeymap } from '@codemirror/commands';
|
||||
import { closeBracketsKeymap } from '@codemirror/autocomplete';
|
||||
import { searchKeymap, highlightSelectionMatches } from '@codemirror/search';
|
||||
import { completionKeymap, closeBracketsKeymap } from '@codemirror/autocomplete';
|
||||
|
||||
// Taken + slightly modified from https://github.com/codemirror/basic-setup/blob/main/src/codemirror.ts
|
||||
|
||||
|
||||
+10
-16
@@ -118,7 +118,7 @@ export const { s, sound } = registerControl(['s', 'n', 'gain'], 'sound');
|
||||
* @param {number | Pattern} position Position in the wavetable from 0 to 1
|
||||
* @synonyms wavetablePosition
|
||||
* @example
|
||||
* s("wt_digital").seg(8).note("F1").wt("0 0.25 0.5 0.75 1")
|
||||
* s("squelch").bank("wt_digital").seg(8).note("F1").wt("0 0.25 0.5 0.75 1")
|
||||
*/
|
||||
export const { wt, wavetablePosition } = registerControl('wt', 'wavetablePosition');
|
||||
|
||||
@@ -519,10 +519,10 @@ export const { fmh, fmh1, fmh2, fmh3, fmh4, fmh5, fmh6, fmh7, fmh8 } = registerM
|
||||
* each other with matrix commands like `fm13`, which would send `fm1` back into
|
||||
* `fm3`
|
||||
*
|
||||
* @name fm
|
||||
* @name fmi
|
||||
* @tags fm, superdough, supradough
|
||||
* @param {number | Pattern} brightness modulation index
|
||||
* @synonyms fmi
|
||||
* @synonyms fm
|
||||
* @example
|
||||
* note("c e g b g e")
|
||||
* .fm("<0 1 2 8 32>")
|
||||
@@ -1988,10 +1988,11 @@ export const { spread } = registerControl('spread');
|
||||
* Set dryness of reverb. See `room` and `size` for more information about reverb.
|
||||
*
|
||||
* @name dry
|
||||
* @tags superdirt, superdough
|
||||
* @tags superdirt
|
||||
* @param {number | Pattern} dry 0 = wet, 1 = dry
|
||||
* @example
|
||||
* n("[0,3,7](3,8)").s("superpiano").room(.7).dry("<0 .5 .75 1>").osc()
|
||||
* @superdirtOnly
|
||||
*
|
||||
*/
|
||||
export const { dry } = registerControl('dry');
|
||||
@@ -2225,7 +2226,7 @@ export const { orbit } = registerControl('orbit', 'o');
|
||||
* otherPat.bmod(..) (to modulate another pattern with the bus)
|
||||
*
|
||||
* @name bus
|
||||
* @tags superdough
|
||||
* @tags superdirt
|
||||
* @param {number | Pattern} number
|
||||
*/
|
||||
export const { bus } = registerControl('bus');
|
||||
@@ -2234,7 +2235,7 @@ export const { bus } = registerControl('bus');
|
||||
* Postgain multiplier prior to sending the signal to the audio bus.
|
||||
*
|
||||
* @name busgain
|
||||
* @tags superdough
|
||||
* @tags superdirt
|
||||
* @synonyms bgain
|
||||
* @param {number | Pattern} number
|
||||
*/
|
||||
@@ -2351,18 +2352,11 @@ export const { offset } = registerControl('offset');
|
||||
**/
|
||||
export const { octaves } = registerControl('octaves');
|
||||
/**
|
||||
* How the voicing is aligned to the anchor
|
||||
* - `below`: top note <= anchor
|
||||
* - `duck`: top note <= anchor, anchor excluded
|
||||
* - `above`: bottom note >= anchor
|
||||
* - `root`: bottom note is the lowest root of the chord >= anchor
|
||||
*
|
||||
* - `oldabove` : old (buggy) behavior of above, kept for legacy reason
|
||||
* - `oldroot` : old (buggy) behavior of root, kept for legacy reason
|
||||
* Remove anchor note from the voicing. Useful for melody harmonization
|
||||
*
|
||||
* @name mode
|
||||
* @tags tonal
|
||||
* @param {string | Pattern} modeName one of {below | above | duck | root | oldabove | oldroot}
|
||||
* @param {string | Pattern} modeName one of {below | above | duck | root}
|
||||
* @example
|
||||
* mode("<below above duck root>").chord("C").voicing()
|
||||
*
|
||||
@@ -2376,7 +2370,7 @@ export const { mode } = registerControl(['mode', 'anchor']);
|
||||
*
|
||||
* @name room
|
||||
* @tags orbit, superdough
|
||||
* @param {number | Pattern} level
|
||||
* @param {number | Pattern} level between 0 and 1
|
||||
* @example
|
||||
* s("bd sd [~ bd] sd").room("<0 .2 .4 .6 .8 1>")
|
||||
* @example
|
||||
|
||||
@@ -10,7 +10,6 @@ import { errorLogger, logger } from './logger.mjs';
|
||||
export class Cyclist {
|
||||
constructor({
|
||||
interval,
|
||||
onSchedule,
|
||||
onTrigger,
|
||||
onToggle,
|
||||
onError,
|
||||
@@ -20,11 +19,6 @@ export class Cyclist {
|
||||
clearInterval,
|
||||
beforeStart,
|
||||
}) {
|
||||
if (onTrigger) {
|
||||
throw new Error(
|
||||
'onTrigger has been dropped. use onSchedule(hap, time, cps) instead, see https://codeberg.org/uzu/strudel/pulls/2138',
|
||||
);
|
||||
}
|
||||
this.started = false;
|
||||
this.beforeStart = beforeStart;
|
||||
this.cps = 0.5;
|
||||
@@ -69,7 +63,12 @@ export class Cyclist {
|
||||
if (hap.hasOnset()) {
|
||||
const targetTime =
|
||||
(hap.whole.begin - this.num_cycles_at_cps_change) / this.cps + this.seconds_at_cps_change + latency;
|
||||
onSchedule?.(hap, targetTime, this.cps);
|
||||
const duration = hap.duration / this.cps;
|
||||
// the following line is dumb and only here for backwards compatibility
|
||||
// see https://codeberg.org/uzu/strudel/pulls/1004
|
||||
const deadline = targetTime - phase;
|
||||
// this onTrigger has another signature
|
||||
onTrigger?.(hap, deadline, duration, this.cps, targetTime);
|
||||
if (hap.value.cps !== undefined && this.cps != hap.value.cps) {
|
||||
this.cps = hap.value.cps;
|
||||
this.num_ticks_since_cps_change = 0;
|
||||
|
||||
+19
-45
@@ -59,11 +59,6 @@ export const bjorklund = function (ons, steps) {
|
||||
* really useful for computer/algorithmic music because they can
|
||||
* describe a large number of rhythms with a couple of numbers.
|
||||
*
|
||||
* A negative number of pulses inverts the pattern
|
||||
* so pulses happen in the gaps of the normal euclidean rhythm.
|
||||
*
|
||||
* A negative number of steps changes it into `euclidLegato`.
|
||||
*
|
||||
* @memberof Pattern
|
||||
* @name euclid
|
||||
* @tags temporal
|
||||
@@ -142,38 +137,8 @@ const _euclidRot = function (pulses, steps, rotation) {
|
||||
return b;
|
||||
};
|
||||
|
||||
const _euclidLegato = function (pulses, steps, rotation, pat) {
|
||||
var bin_pat = _euclidRot(pulses, steps, 0);
|
||||
// Because the `gapless` algorithm logic assumes the first entry in bin_pat is a 1,
|
||||
// we rotate the pattern so the first onset is at the start.
|
||||
const firstOnset = bin_pat.indexOf(1);
|
||||
bin_pat = rotate(bin_pat, firstOnset);
|
||||
steps = Math.abs(steps);
|
||||
const gapless = bin_pat
|
||||
.join('')
|
||||
.split('1')
|
||||
.slice(1)
|
||||
.map((s) => [s.length + 1, true]);
|
||||
return pat.struct(timeCat(...gapless).late(Fraction(rotation + firstOnset).div(steps)));
|
||||
};
|
||||
|
||||
const _euclid = function (pulses, steps, rotation, pat) {
|
||||
if (steps === 0 || pulses === 0) {
|
||||
return silence;
|
||||
}
|
||||
const cycles = Math.ceil(Math.abs(pulses) / Math.abs(steps));
|
||||
const totalSteps = cycles * steps;
|
||||
if (totalSteps < 0) {
|
||||
return _euclidLegato(pulses, -totalSteps, rotation, pat.fast(cycles)).slow(cycles);
|
||||
}
|
||||
return pat
|
||||
.fast(cycles)
|
||||
.struct(_euclidRot(pulses, totalSteps, rotation))
|
||||
.slow(cycles);
|
||||
};
|
||||
|
||||
export const euclid = register('euclid', function (pulses, steps, pat) {
|
||||
return _euclid(pulses, steps, 0, pat);
|
||||
return pat.struct(_euclidRot(pulses, steps, 0));
|
||||
});
|
||||
|
||||
export const bjork = register('bjork', function (euc, pat) {
|
||||
@@ -181,18 +146,16 @@ export const bjork = register('bjork', function (euc, pat) {
|
||||
euc = [euc];
|
||||
}
|
||||
const [pulses, steps = pulses, rot = 0] = euc;
|
||||
return _euclid(pulses, steps, rot, pat);
|
||||
return pat.struct(_euclidRot(pulses, steps, rot));
|
||||
});
|
||||
|
||||
export const { euclidrot, euclidRot } = register(['euclidrot', 'euclidRot'], function (pulses, steps, rotation, pat) {
|
||||
return _euclid(pulses, steps, rotation, pat);
|
||||
return pat.struct(_euclidRot(pulses, steps, rotation));
|
||||
});
|
||||
|
||||
/**
|
||||
* Similar to `euclid`, but each pulse is held until the next pulse,
|
||||
* so there will be no gaps.
|
||||
*
|
||||
* A negative number of steps changes it into `euclid`.
|
||||
* @name euclidLegato
|
||||
* @memberof Pattern
|
||||
* @tags temporal
|
||||
@@ -204,16 +167,27 @@ export const { euclidrot, euclidRot } = register(['euclidrot', 'euclidRot'], fun
|
||||
* note("c3").euclidLegato(3,8)
|
||||
*/
|
||||
|
||||
const _euclidLegato = function (pulses, steps, rotation, pat) {
|
||||
if (pulses < 1) {
|
||||
return silence;
|
||||
}
|
||||
const bin_pat = _euclidRot(pulses, steps, 0);
|
||||
const gapless = bin_pat
|
||||
.join('')
|
||||
.split('1')
|
||||
.slice(1)
|
||||
.map((s) => [s.length + 1, true]);
|
||||
return pat.struct(timeCat(...gapless)).late(Fraction(rotation).div(steps));
|
||||
};
|
||||
|
||||
export const euclidLegato = register(['euclidLegato'], function (pulses, steps, pat) {
|
||||
return _euclid(pulses, -steps, 0, pat);
|
||||
return _euclidLegato(pulses, steps, 0, pat);
|
||||
});
|
||||
|
||||
/**
|
||||
* Similar to `euclid`, but each pulse is held until the next pulse,
|
||||
* so there will be no gaps, and has an additional parameter for 'rotating'
|
||||
* the resulting sequence.
|
||||
*
|
||||
* A negative number of steps changes it into `euclidRot`.
|
||||
* the resulting sequence
|
||||
* @name euclidLegatoRot
|
||||
* @memberof Pattern
|
||||
* @tags temporal
|
||||
@@ -224,7 +198,7 @@ export const euclidLegato = register(['euclidLegato'], function (pulses, steps,
|
||||
* note("c3").euclidLegatoRot(3,5,2)
|
||||
*/
|
||||
export const euclidLegatoRot = register(['euclidLegatoRot'], function (pulses, steps, rotation, pat) {
|
||||
return _euclid(pulses, -steps, rotation, pat);
|
||||
return _euclidLegato(pulses, steps, rotation, pat);
|
||||
});
|
||||
|
||||
/**
|
||||
|
||||
@@ -8,12 +8,7 @@ import { logger } from './logger.mjs';
|
||||
import { ClockCollator, cycleToSeconds } from './util.mjs';
|
||||
|
||||
export class NeoCyclist {
|
||||
constructor({ onSchedule, onToggle, getTime, onTrigger }) {
|
||||
if (onTrigger) {
|
||||
throw new Error(
|
||||
'onTrigger has been dropped. use onSchedule(hap, time, cps) instead, see https://codeberg.org/uzu/strudel/pulls/2138',
|
||||
);
|
||||
}
|
||||
constructor({ onTrigger, onToggle, getTime }) {
|
||||
this.started = false;
|
||||
this.cps = 0.5;
|
||||
this.getTime = getTime; // get absolute time
|
||||
@@ -48,7 +43,8 @@ export class NeoCyclist {
|
||||
if (hap.hasOnset()) {
|
||||
const timeUntilTrigger = cycleToSeconds(hap.whole.begin - this.cycle, this.cps);
|
||||
const targetTime = timeUntilTrigger + currentTime + this.latency;
|
||||
onSchedule?.(hap, targetTime, this.cps);
|
||||
const duration = cycleToSeconds(hap.duration, this.cps);
|
||||
onTrigger?.(hap, 0, duration, this.cps, targetTime);
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
+72
-413
@@ -27,7 +27,6 @@ import {
|
||||
import drawLine from './drawLine.mjs';
|
||||
import { errorLogger, logger } from './logger.mjs';
|
||||
import { strudelScope } from './evaluate.mjs';
|
||||
import { getClockTime } from './schedulerState.mjs';
|
||||
|
||||
let stringParser;
|
||||
|
||||
@@ -505,25 +504,10 @@ export class Pattern {
|
||||
|
||||
/**
|
||||
* Returns a new pattern with the given function applied to the list of haps returned by every query.
|
||||
*
|
||||
* As an end user, you will most likely not need to use this; look at `withContext`, `withHapSpan`, etc. instead.
|
||||
* @tags internals
|
||||
* @param {Function} func
|
||||
* @returns Pattern
|
||||
* @noAutocomplete
|
||||
* @example
|
||||
* note("[a b, c d] a b c d").s("gm_piano").withHaps(x=>{
|
||||
* if (x.length > 1) {
|
||||
* x = x.map(hap => hap.withValue(val => {
|
||||
* return {
|
||||
* n: 1,
|
||||
* // select gm_piano:1 sample
|
||||
* ...val
|
||||
* }
|
||||
* }));
|
||||
* }
|
||||
* return x
|
||||
* })
|
||||
*/
|
||||
withHaps(func) {
|
||||
const result = new Pattern((state) => func(this.query(state), state));
|
||||
@@ -533,23 +517,10 @@ export class Pattern {
|
||||
|
||||
/**
|
||||
* As with `withHaps`, but applies the function to every hap, rather than every list of haps.
|
||||
*
|
||||
* As an end user, you will most likely not need to use this; look at `withContext`, `withHapSpan`, etc. instead.
|
||||
* @tags internals
|
||||
* @param {Function} func
|
||||
* @returns Pattern
|
||||
* @noAutocomplete
|
||||
* @example
|
||||
* note("c a f e").withHap(x=>{
|
||||
* if (x.value.note == 'c') {
|
||||
* x.value.s = 'gm_piano'
|
||||
* }
|
||||
* else {
|
||||
* x.value.s = 'gm_piano'
|
||||
* x.value.n = 2
|
||||
* }
|
||||
* return x
|
||||
* })
|
||||
*/
|
||||
withHap(func) {
|
||||
return this.withHaps((haps) => haps.map(func));
|
||||
@@ -879,26 +850,6 @@ export class Pattern {
|
||||
return stack(this, ...pats);
|
||||
}
|
||||
|
||||
stackLeft(...pats) {
|
||||
return stackLeft(this, ...pats);
|
||||
}
|
||||
|
||||
stackRight(...pats) {
|
||||
return stackRight(this, ...pats);
|
||||
}
|
||||
|
||||
stackCenter(...pats) {
|
||||
return stackCenter(this, ...pats);
|
||||
}
|
||||
|
||||
stackCentre(...pats) {
|
||||
return stackCentre(this, ...pats);
|
||||
}
|
||||
|
||||
stackRepeat(...pats) {
|
||||
return stackRepeat(this, ...pats);
|
||||
}
|
||||
|
||||
sequence(...pats) {
|
||||
return sequence(this, ...pats);
|
||||
}
|
||||
@@ -921,41 +872,23 @@ export class Pattern {
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// Context methods - ones that deal with metadata
|
||||
|
||||
/**
|
||||
* Attaches a function that is called for each hap onset.
|
||||
* @name onSchedule
|
||||
* @memberof Pattern
|
||||
* @example
|
||||
* s("bd sd").onSchedule((hap, time, cps) => {
|
||||
* console.log('hap scheduled', time, cps);
|
||||
* })
|
||||
*/
|
||||
onSchedule(onSchedule, dominant = true) {
|
||||
onTrigger(onTrigger, dominant = true) {
|
||||
return this.withHap((hap) =>
|
||||
hap.setContext({
|
||||
...hap.context,
|
||||
onSchedule: (scheduleHap, t, cps) => {
|
||||
onTrigger: (...args) => {
|
||||
// run previously set trigger, if it exists
|
||||
hap.context.onSchedule?.(scheduleHap, t, cps);
|
||||
onSchedule(scheduleHap, t, cps);
|
||||
hap.context.onTrigger?.(...args);
|
||||
onTrigger(...args);
|
||||
},
|
||||
// if dominantSchedule is set to true, the default output (webaudio) will be disabled
|
||||
// if dominantTrigger is set to true, the default output (webaudio) will be disabled
|
||||
// when using multiple triggers, you cannot flip this flag to false again!
|
||||
// example: x.csound('CooLSynth').log() as well as x.log().csound('CooLSynth') should work the same
|
||||
dominantSchedule: hap.context.dominantSchedule || dominant,
|
||||
dominantTrigger: hap.context.dominantTrigger || dominant,
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
// legacy:
|
||||
onTrigger(onTrigger, dominant = true) {
|
||||
console.warn('onTrigger is deprecated.. use onSchedule(hap, time, cps) instead');
|
||||
return this.onSchedule((hap, t, cps) => {
|
||||
const currentTime = getClockTime();
|
||||
return onTrigger(hap, currentTime, cps, t);
|
||||
}, dominant);
|
||||
}
|
||||
|
||||
/**
|
||||
* Writes the content of the current event to the console (visible in the side menu).
|
||||
* @tags visualization
|
||||
@@ -965,7 +898,7 @@ export class Pattern {
|
||||
* s("bd sd").log()
|
||||
*/
|
||||
log(func = (hap) => `[hap] ${hap.showWhole(true)}`, getData = (hap) => ({ hap })) {
|
||||
return this.onSchedule((...args) => {
|
||||
return this.onTrigger((...args) => {
|
||||
logger(func(...args), undefined, getData(...args));
|
||||
}, false);
|
||||
}
|
||||
@@ -1069,7 +1002,7 @@ export const arpWith = register('arpWith', (func, pat) => {
|
||||
* */
|
||||
export const arp = register(
|
||||
'arp',
|
||||
(indices, pat) => pat.arpWith((haps) => reify(indices).fmap((i) => haps[_mod(i, haps.length)])),
|
||||
(indices, pat) => pat.arpWith((haps) => reify(indices).fmap((i) => haps[i % haps.length])),
|
||||
false,
|
||||
);
|
||||
|
||||
@@ -1141,7 +1074,7 @@ const COMPOSERS = {
|
||||
* @param {Pattern} pat
|
||||
* @returns {Pattern}
|
||||
* @memberof Pattern
|
||||
* @tags internals, combiners
|
||||
* @tags internal, combiners
|
||||
* @example
|
||||
* // because input pattern has `s` set,
|
||||
* // it overrides the "sine" declared earlier
|
||||
@@ -1166,7 +1099,7 @@ const COMPOSERS = {
|
||||
* @param {Pattern} pat
|
||||
* @memberof Pattern
|
||||
* @returns {Pattern}
|
||||
* @tags internals, combiners
|
||||
* @tags internal, combiners
|
||||
* @example
|
||||
* // notes, already defined, will stay "c a f e",
|
||||
* // while "s", not defined, will be set to "piano"
|
||||
@@ -1223,163 +1156,24 @@ const COMPOSERS = {
|
||||
* @tags math
|
||||
*/
|
||||
div: [numeralArgs((a, b) => a / b)],
|
||||
/**
|
||||
*
|
||||
* Divides each number by the given factor and returns the remainder
|
||||
* @name mod
|
||||
* @memberof Pattern
|
||||
* @tags math
|
||||
*/
|
||||
mod: [numeralArgs(_mod)],
|
||||
/**
|
||||
*
|
||||
* Raises each number to the power of the given factor
|
||||
* @name pow
|
||||
* @memberof Pattern
|
||||
* @tags math
|
||||
*/
|
||||
pow: [numeralArgs(Math.pow)],
|
||||
/**
|
||||
*
|
||||
* Performs a bitwise `and` on each number and the given factor
|
||||
* @name band
|
||||
* @memberof Pattern
|
||||
* @tags math
|
||||
*/
|
||||
band: [numeralArgs((a, b) => a & b)],
|
||||
/**
|
||||
*
|
||||
* Performs a bitwise `or` on each number and the given factor
|
||||
* @name bor
|
||||
* @memberof Pattern
|
||||
* @tags math
|
||||
*/
|
||||
bor: [numeralArgs((a, b) => a | b)],
|
||||
/**
|
||||
*
|
||||
* Performs a bitwise `xor` on each number and the given factor
|
||||
* @name bxor
|
||||
* @memberof Pattern
|
||||
* @tags math
|
||||
*/
|
||||
bxor: [numeralArgs((a, b) => a ^ b)],
|
||||
/**
|
||||
*
|
||||
* Performs a bitwise `left shift` on each number by the given factor
|
||||
* @name blshift
|
||||
* @memberof Pattern
|
||||
* @tags math
|
||||
*/
|
||||
blshift: [numeralArgs((a, b) => a << b)],
|
||||
/**
|
||||
*
|
||||
* Performs a bitwise `right shift` on each number by the given factor
|
||||
* @name brshift
|
||||
* @memberof Pattern
|
||||
* @tags math
|
||||
*/
|
||||
brshift: [numeralArgs((a, b) => a >> b)],
|
||||
|
||||
// TODO - force numerical comparison if both look like numbers?
|
||||
/**
|
||||
* performs a < b
|
||||
* @name lt
|
||||
* @memberof Pattern
|
||||
* @tags math
|
||||
* @param {any} a
|
||||
* @param {any} b
|
||||
* @returns Pattern with boolean value(s)
|
||||
*/
|
||||
lt: [(a, b) => a < b],
|
||||
/**
|
||||
* performs a > b
|
||||
* @name gt
|
||||
* @memberof Pattern
|
||||
* @tags math
|
||||
* @param {any} a
|
||||
* @param {any} b
|
||||
* @returns Pattern with boolean value(s)
|
||||
*/
|
||||
gt: [(a, b) => a > b],
|
||||
/**
|
||||
* performs a <= b
|
||||
* @name lte
|
||||
* @memberof Pattern
|
||||
* @tags math
|
||||
* @param {any} a
|
||||
* @param {any} b
|
||||
* @returns Pattern with boolean value(s)
|
||||
*/
|
||||
lte: [(a, b) => a <= b],
|
||||
/**
|
||||
* performs a >= b
|
||||
* @name gte
|
||||
* @memberof Pattern
|
||||
* @tags math
|
||||
* @param {any} a
|
||||
* @param {any} b
|
||||
* @returns Pattern with boolean value(s)
|
||||
*/
|
||||
gte: [(a, b) => a >= b],
|
||||
/**
|
||||
* performs a == b
|
||||
* @name eq
|
||||
* @memberof Pattern
|
||||
* @tags math
|
||||
* @param {any} a
|
||||
* @param {any} b
|
||||
* @returns Pattern with boolean value(s)
|
||||
*/
|
||||
eq: [(a, b) => a == b],
|
||||
/**
|
||||
* performs a === b (strictly equal)
|
||||
* @name eqt
|
||||
* @memberof Pattern
|
||||
* @tags math
|
||||
* @param {any} a
|
||||
* @param {any} b
|
||||
* @returns Pattern with boolean value(s)
|
||||
*/
|
||||
eqt: [(a, b) => a === b],
|
||||
/**
|
||||
* performs a != b
|
||||
* @name ne
|
||||
* @memberof Pattern
|
||||
* @tags math
|
||||
* @param {any} a
|
||||
* @param {any} b
|
||||
* @returns Pattern with boolean value(s)
|
||||
*/
|
||||
ne: [(a, b) => a != b],
|
||||
/**
|
||||
* performs a !== b (strictly not equal)
|
||||
* @name net
|
||||
* @memberof Pattern
|
||||
* @tags math
|
||||
* @param {any} a
|
||||
* @param {any} b
|
||||
* @returns Pattern with boolean value(s)
|
||||
*/
|
||||
net: [(a, b) => a !== b],
|
||||
/**
|
||||
* performs a && b
|
||||
* @name and
|
||||
* @memberof Pattern
|
||||
* @tags math
|
||||
* @param {any} a
|
||||
* @param {any} b
|
||||
* @returns Pattern with boolean value(s)
|
||||
*/
|
||||
and: [(a, b) => a && b],
|
||||
/**
|
||||
* performs a || b
|
||||
* @name or
|
||||
* @memberof Pattern
|
||||
* @tags math
|
||||
* @param {any} a
|
||||
* @param {any} b
|
||||
* @returns Pattern with boolean value(s)
|
||||
*/
|
||||
or: [(a, b) => a || b],
|
||||
|
||||
// bitwise ops
|
||||
@@ -1655,19 +1449,7 @@ export function sequenceP(pats) {
|
||||
export function stack(...pats) {
|
||||
// Array test here is to avoid infinite recursions..
|
||||
pats = pats.map((pat) => (Array.isArray(pat) ? sequence(...pat) : reify(pat)));
|
||||
const query = (state) =>
|
||||
flatten(
|
||||
pats.map((pat) => {
|
||||
try {
|
||||
// An error occurring in one part of the stack should not break
|
||||
// playback of the other parts of the stack.
|
||||
return pat.query(state);
|
||||
} catch (e) {
|
||||
errorLogger(e);
|
||||
return [];
|
||||
}
|
||||
}),
|
||||
);
|
||||
const query = (state) => flatten(pats.map((pat) => pat.query(state)));
|
||||
const result = new Pattern(query);
|
||||
if (__steps) {
|
||||
result._steps = lcm(...pats.map((pat) => pat._steps));
|
||||
@@ -1675,6 +1457,27 @@ export function stack(...pats) {
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* The given items are played at the same time at the same length.
|
||||
*
|
||||
* @tags temporal
|
||||
* @return {Pattern}
|
||||
* @synonyms polyrhythm, pr
|
||||
* @example
|
||||
* mute_stack("g3", "b3", ["e4", "d4"]).note()
|
||||
* // "g3,b3,[e4 d4]".note()
|
||||
*
|
||||
* @example
|
||||
* // As a chained function:
|
||||
* s("hh*4").mute_stack(
|
||||
* note("c4(5,8)")
|
||||
* )
|
||||
*/
|
||||
export function mute_stack(...pats) {
|
||||
return silence;
|
||||
}
|
||||
|
||||
function _stackWith(func, pats) {
|
||||
pats = pats.map((pat) => (Array.isArray(pat) ? sequence(...pat) : reify(pat)));
|
||||
if (pats.length === 0) {
|
||||
@@ -1688,18 +1491,6 @@ function _stackWith(func, pats) {
|
||||
return stack(...func(steps, pats));
|
||||
}
|
||||
|
||||
/**
|
||||
* The input patterns are aligned to the left, with silence padded to the shorter pattern(s) in the final steps if there's a stepcount disparity. See also `stackRight` and `stackCenter/stackCentre`
|
||||
*
|
||||
* @name stackLeft
|
||||
* @tags temporal, stepwise, combiners
|
||||
* @return {Pattern}
|
||||
* @example
|
||||
* stackLeft("0 1 2 3", "3 4", "[4 5 6] 7 8 9 10").scale("c:minor").note()
|
||||
* @example
|
||||
* // chainable
|
||||
* "0 1 2 3".stackLeft("3 4", "[4 5 6] 7 8 9 10").scale("c:minor").note()
|
||||
*/
|
||||
export function stackLeft(...pats) {
|
||||
return _stackWith(
|
||||
(steps, pats) => pats.map((pat) => (pat._steps.eq(steps) ? pat : stepcat(pat, gap(steps.sub(pat._steps))))),
|
||||
@@ -1707,18 +1498,6 @@ export function stackLeft(...pats) {
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* The input patterns are aligned to the right, with silence padded to the shorter pattern(s) in the initial steps if there's a stepcount disparity. See also `stackLeft` and `stackCenter/stackCentre`
|
||||
*
|
||||
* @name stackRight
|
||||
* @tags temporal, stepwise, combiners
|
||||
* @return {Pattern}
|
||||
* @example
|
||||
* stackRight("0 1 2 3", "3 4", "[4 5 6] 7 8 9 10").scale("c:minor").note()
|
||||
* @example
|
||||
* // chainable
|
||||
* "0 1 2 3".stackRight("3 4", "[4 5 6] 7 8 9 10").scale("c:minor").note()
|
||||
*/
|
||||
export function stackRight(...pats) {
|
||||
return _stackWith(
|
||||
(steps, pats) => pats.map((pat) => (pat._steps.eq(steps) ? pat : stepcat(gap(steps.sub(pat._steps)), pat))),
|
||||
@@ -1726,19 +1505,7 @@ export function stackRight(...pats) {
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* The input patterns are aligned to the right, with silence padded to the shorter pattern(s) in the initial steps if there's a stepcount disparity. See also `stackLeft` and `stackRight`
|
||||
* @name stackCenter
|
||||
* @tags temporal, stepwise, combiners
|
||||
* @synonyms stackCentre
|
||||
* @return {Pattern}
|
||||
* @example
|
||||
* stackCenter("0 1 2 3", "3 4", "[4 5 6] 7 8 9 10").scale("c:minor").note()
|
||||
* @example
|
||||
* // chainable
|
||||
* "0 1 2 3".stackCenter("3 4", "[4 5 6] 7 8 9 10").scale("c:minor").note()
|
||||
*/
|
||||
export function stackCenter(...pats) {
|
||||
export function stackCentre(...pats) {
|
||||
return _stackWith(
|
||||
(steps, pats) =>
|
||||
pats.map((pat) => {
|
||||
@@ -1752,25 +1519,6 @@ export function stackCenter(...pats) {
|
||||
);
|
||||
}
|
||||
|
||||
export function stackCentre(...pats) {
|
||||
return stackCenter(...pats);
|
||||
}
|
||||
|
||||
/**
|
||||
* Shorthand for `pm(patterns).pace(m)` where m is the max step count in the input patterns
|
||||
* @name stackRepeat
|
||||
* @tags temporal, stepwise, combiners
|
||||
* @return {Pattern}
|
||||
* @example
|
||||
* stackRepeat("0 1 2 3", "3 4", "[4 5 6] 7 8 9 10").scale("c:minor").note()
|
||||
* @example
|
||||
* // chainable
|
||||
* "0 1 2 3".stackRepeat("3 4", "[4 5 6] 7 8 9 10").scale("c:minor").note()
|
||||
*/
|
||||
export function stackRepeat(...pats) {
|
||||
return stackBy(reify('repeat'), ...pats);
|
||||
}
|
||||
|
||||
export function stackBy(by, ...pats) {
|
||||
const [left, ...right] = pats.map((pat) => pat._steps);
|
||||
const steps = left.maximum(...right);
|
||||
@@ -1802,9 +1550,7 @@ export function slowcat(...pats) {
|
||||
// Array test here is to avoid infinite recursions..
|
||||
pats = pats.map((pat) => (Array.isArray(pat) ? fastcat(...pat) : reify(pat)));
|
||||
|
||||
if (!pats.length) {
|
||||
return silence;
|
||||
} else if (pats.length == 1) {
|
||||
if (pats.length == 1) {
|
||||
return pats[0];
|
||||
}
|
||||
|
||||
@@ -1812,6 +1558,10 @@ export function slowcat(...pats) {
|
||||
const span = state.span;
|
||||
const pat_n = _mod(span.begin.sam(), pats.length);
|
||||
const pat = pats[pat_n];
|
||||
if (!pat) {
|
||||
// pat_n can be negative, if the span is in the past..
|
||||
return [];
|
||||
}
|
||||
// A bit of maths to make sure that cycles from constituent patterns aren't skipped.
|
||||
// For example if three patterns are slowcat-ed, the fourth cycle of the result should
|
||||
// be the second (rather than fourth) cycle from the first pattern.
|
||||
@@ -1828,14 +1578,11 @@ export function slowcat(...pats) {
|
||||
* @return {Pattern}
|
||||
*/
|
||||
export function slowcatPrime(...pats) {
|
||||
if (!pats.length) {
|
||||
return silence;
|
||||
}
|
||||
pats = pats.map(reify);
|
||||
const query = function (state) {
|
||||
const pat_n = _mod(Math.floor(state.span.begin), pats.length);
|
||||
const pat = pats[pat_n];
|
||||
return pat.query(state);
|
||||
const pat_n = Math.floor(state.span.begin) % pats.length;
|
||||
const pat = pats[pat_n]; // can be undefined for same cases e.g. /#cHVyZSg0MikKICAuZXZlcnkoMyxhZGQoNykpCiAgLmxhdGUoLjUp
|
||||
return pat?.query(state) || [];
|
||||
};
|
||||
return new Pattern(query).splitQueries();
|
||||
}
|
||||
@@ -1885,10 +1632,10 @@ export function arrange(...sections) {
|
||||
* @tags combiners
|
||||
* @return {Pattern}
|
||||
* @example
|
||||
* seqPLoop(
|
||||
* [0, 2, "bd(3,8)"],
|
||||
* [1, 3, "cp(3,8)"]
|
||||
* ).sound()
|
||||
seqPLoop(
|
||||
[0, 2, "bd(3,8)"],
|
||||
[1, 3, "cp(3,8)"]
|
||||
).sound()
|
||||
*/
|
||||
export function seqPLoop(...parts) {
|
||||
let total = Fraction(0);
|
||||
@@ -2354,8 +2101,8 @@ export const ply = register('ply', function (factor, pat) {
|
||||
* @example
|
||||
* s("bd hh sd hh").fast(2) // s("[bd hh sd hh]*2")
|
||||
*/
|
||||
export const fast = register(
|
||||
'fast',
|
||||
export const { fast, density } = register(
|
||||
['fast', 'density'],
|
||||
function (factor, pat) {
|
||||
if (factor === 0) {
|
||||
return silence;
|
||||
@@ -2565,11 +2312,11 @@ export const { zoomArc, zoomarc } = register(['zoomArc', 'zoomarc'], function (a
|
||||
* @param {number} slices to play
|
||||
* @example
|
||||
* note("0 1 2 3 4 5 6 7".scale('c:mixolydian'))
|
||||
* .bite(4, "3 2 1 0")
|
||||
*.bite(4, "3 2 1 0")
|
||||
* @example
|
||||
* sound("bd - bd bd*2, - sd:6 - sd:5 sd:1 - [- sd:2] -, hh [- cp:7]")
|
||||
* .bank("RolandTR909").speed(1.2)
|
||||
* .bite(4, "0 0 [1 2] <3 2> 0 0 [2 1] 3")
|
||||
.bank("RolandTR909").speed(1.2)
|
||||
.bite(4, "0 0 [1 2] <3 2> 0 0 [2 1] 3")
|
||||
*/
|
||||
export const bite = register(
|
||||
'bite',
|
||||
@@ -2586,74 +2333,6 @@ export const bite = register(
|
||||
false,
|
||||
);
|
||||
|
||||
/**
|
||||
* Similar to `struct`, but every hap in the structure pattern plays the next
|
||||
* cycle of the main pattern.
|
||||
* With a different number of cycles in the main pattern and haps in the
|
||||
* structure pattern, this creates an isorhythm.
|
||||
*
|
||||
* Note: This function works on the assumption that the structure pattern
|
||||
* repeats every cycle. If the structure pattern only repeats after multiple
|
||||
* cycles, it may skip or repeat certain parts of the melody.
|
||||
* @tags temporal
|
||||
* @name isobite
|
||||
* @synonyms cycleStruct, cyclestruct
|
||||
* @memberof Pattern
|
||||
* @param {Pattern} structure structure of the pattern
|
||||
* @example
|
||||
* "<0 1 2 3 4 5>".isobite("[x - x*2]*2").n().scale("c:major")
|
||||
* // the same as "0 - [1 2] 3 - [4 5]".n().scale("c:major")
|
||||
*
|
||||
* @example
|
||||
* "<0 1 2 3 4>".isobite("x - x").n().scale("c:major")
|
||||
* // the same as "<[0 - 1] [2 - 3] [4 - 0] [1 - 2] [3 - 4]>".n().scale("c:major")
|
||||
*
|
||||
* @example
|
||||
* // Here the structure pattern repeats after 2 cycles,
|
||||
* // so certain haps from the melody are skipped.
|
||||
* "<0 1 2 3>".isobite("x x*2".slow(2)).n().scale("c:major")
|
||||
* // the same as "<[0] [2 3] [2] [2 3]>".n().scale("c:major")
|
||||
*
|
||||
* @example
|
||||
* // This can be avoided by making the struct pattern 1 cycle,
|
||||
* // and slowing the whole pattern down as follows:
|
||||
* "<0 1 2 3>".isobite("x x*2").slow(2).n().scale("c:major")
|
||||
* // the same as "<[0] [1 2] [3] [0 1] [2] [3 0] [1] [2 3]>".n().scale("c:major")
|
||||
*/
|
||||
export const { isobite, cyclestruct, cycleStruct } = register(
|
||||
['isobite', 'cyclestruct', 'cycleStruct'],
|
||||
(structure, pat) => {
|
||||
const structPat = new Pattern((state) => {
|
||||
const haps_cycle = structure
|
||||
.withQuerySpan((span) => span.begin.wholeCycle())
|
||||
.query(state)
|
||||
.filter((hap) => hap.value != 0)
|
||||
.sort((a, b) => a.whole.begin - b.whole.begin)
|
||||
.map((hap, i) => hap.withValue((_) => i));
|
||||
|
||||
const haps = [];
|
||||
for (const hap of haps_cycle) {
|
||||
const new_part = state.span.intersection(hap.part);
|
||||
if (new_part) {
|
||||
haps.push(new Hap(hap.whole, new_part, hap.value, hap.context));
|
||||
}
|
||||
}
|
||||
return haps;
|
||||
}).splitQueries();
|
||||
|
||||
const stepsPattern = new Pattern((state) => {
|
||||
const nrHaps = structure
|
||||
.withQuerySpan((span) => span.begin.wholeCycle())
|
||||
.query(state)
|
||||
.filter((hap) => hap.value != 0).length;
|
||||
return [new Hap(state.span.begin.wholeCycle(), state.span, nrHaps, {})];
|
||||
}).splitQueries();
|
||||
|
||||
return pat.fast(stepsPattern).bite(stepsPattern, structPat);
|
||||
},
|
||||
false,
|
||||
);
|
||||
|
||||
/**
|
||||
* Selects the given fraction of the pattern and repeats that part to fill the remainder of the cycle.
|
||||
* @tags temporal
|
||||
@@ -2760,12 +2439,8 @@ export const off = register('off', function (time_pat, func, pat) {
|
||||
* Returns a new pattern where every other cycle is played once, twice as
|
||||
* fast, and offset in time by one quarter of a cycle. Creates a kind of
|
||||
* breakbeat feel.
|
||||
* @name brak
|
||||
* @tags temporal
|
||||
* @returns Pattern
|
||||
* @memberof Pattern
|
||||
* @example
|
||||
* s("bd hh!2 rim").brak()
|
||||
*/
|
||||
export const brak = register('brak', function (pat) {
|
||||
return pat.when(slowcat(false, true), (x) => fastcat(x, silence)._late(0.25));
|
||||
@@ -3254,29 +2929,10 @@ export const { ribbon, rib } = register(['ribbon', 'rib'], (offset, cycles, pat)
|
||||
pat.early(offset).restart(pure(1).slow(cycles)),
|
||||
);
|
||||
|
||||
/**
|
||||
* Sets the pattern's color to the given [hsla](https://www.w3schools.com/htmL/html_colors_hsl.asp)
|
||||
*
|
||||
* @name hsla
|
||||
* @param {Number} hue (0 - 360)
|
||||
* @param {Number} saturation percentage (0 - 100)
|
||||
* @param {Number} lightness percentage (0 - 100)
|
||||
* @param {Number} alpha (transparency) (0.0 - 1.0)
|
||||
* @tags visualization
|
||||
*/
|
||||
export const hsla = register('hsla', (h, s, l, a, pat) => {
|
||||
return pat.color(`hsla(${h}turn,${s * 100}%,${l * 100}%,${a})`);
|
||||
});
|
||||
|
||||
/**
|
||||
* Sets the pattern's color to the given [hsl](https://www.w3schools.com/htmL/html_colors_hsl.asp)
|
||||
*
|
||||
* @name hsl
|
||||
* @param {Number} hue (0 - 360)
|
||||
* @param {Number} saturation percentage (0 - 100)
|
||||
* @param {Number} lightness percentage (0 - 100)
|
||||
* @tags visualization
|
||||
*/
|
||||
export const hsl = register('hsl', (h, s, l, pat) => {
|
||||
return pat.color(`hsl(${h}turn,${s * 100}%,${l * 100}%)`);
|
||||
});
|
||||
@@ -3632,7 +3288,7 @@ export const drop = stepRegister('drop', function (i, pat) {
|
||||
* @tags stepwise
|
||||
* @example
|
||||
* stepcat(
|
||||
* sound("bd bd - <cp hh>").extend(2),
|
||||
* sound("bd bd - cp").extend(2),
|
||||
* sound("bd - sd -")
|
||||
* ).pace(8)
|
||||
*/
|
||||
@@ -3643,12 +3299,15 @@ export const extend = stepRegister('extend', function (factor, pat) {
|
||||
/**
|
||||
* *Experimental*
|
||||
*
|
||||
* `replicate` is similar to `extend`, except that `replicate` will "replicate" the thing being extended. This will only differ from `extend` when the input pattern differs from cycle to cycle.
|
||||
* `replicate` is similar to `fast` in that it increases its density, but it also increases the step count
|
||||
* accordingly. So `stepcat("a b".replicate(2), "c d")` would be the same as `"a b a b c d"`, whereas
|
||||
* `stepcat("a b".fast(2), "c d")` would be the same as `"[a b] [a b] c d"`.
|
||||
*
|
||||
* TODO: find out how this function differs from extend
|
||||
* @tags stepwise
|
||||
* @example
|
||||
* stepcat(
|
||||
* sound("bd bd - <cp hh>").replicate(2),
|
||||
* sound("bd bd - cp").replicate(2),
|
||||
* sound("bd - sd -")
|
||||
* ).pace(8)
|
||||
*/
|
||||
@@ -3744,8 +3403,8 @@ export const growlist = (amount, pat) => pat.growlist(amount);
|
||||
* "tha dhi thom nam".shrink("1 -1").sound().bank("mridangam").pace(4)
|
||||
* @example
|
||||
* note("0 1 2 3 4 5 6 7".scale("C:ritusen")).sound("folkharp")
|
||||
* .shrink("1 -1").pace(8)
|
||||
*
|
||||
.shrink("1 -1").pace(8)
|
||||
|
||||
*/
|
||||
|
||||
export const shrink = register(
|
||||
@@ -3784,7 +3443,7 @@ export const shrink = register(
|
||||
* "tha dhi thom nam".grow("1 -1").sound().bank("mridangam").pace(4)
|
||||
* @example
|
||||
* note("0 1 2 3 4 5 6 7".scale("C:ritusen")).sound("folkharp")
|
||||
* .grow("1 -1").pace(8)
|
||||
.grow("1 -1").pace(8)
|
||||
*/
|
||||
|
||||
export const grow = register(
|
||||
@@ -3808,17 +3467,17 @@ export const grow = register(
|
||||
|
||||
/**
|
||||
* *Experimental*
|
||||
*
|
||||
* Inserts a pattern into a list of patterns. On the first repetition it will be inserted at the end of the list, then moved backwards through the list
|
||||
* on successive repetitions. The patterns are added together stepwise, with all repetitions taking place over a single cycle. Using `pace` to set the
|
||||
*
|
||||
* Inserts a pattern into a list of patterns. On the first repetition it will be inserted at the end of the list, then moved backwards through the list
|
||||
* on successive repetitions. The patterns are added together stepwise, with all repetitions taking place over a single cycle. Using `pace` to set the
|
||||
* number of steps per cycle is therefore usually recommended.
|
||||
*
|
||||
* @tags stepwise
|
||||
* @return {Pattern}
|
||||
* @example
|
||||
* "[c g]".tour("e f", "e f g", "g f e c").note()
|
||||
* .sound("folkharp")
|
||||
* .pace(8)
|
||||
.sound("folkharp")
|
||||
.pace(8)
|
||||
*/
|
||||
export const tour = function (pat, ...many) {
|
||||
return pat.tour(...many);
|
||||
@@ -3836,16 +3495,16 @@ Pattern.prototype.tour = function (...many) {
|
||||
|
||||
/**
|
||||
* *Experimental*
|
||||
*
|
||||
* 'zips' together the steps of the provided patterns. This can create a long repetition, taking place over a single, dense cycle.
|
||||
*
|
||||
* 'zips' together the steps of the provided patterns. This can create a long repetition, taking place over a single, dense cycle.
|
||||
* Using `pace` to set the number of steps per cycle is therefore usually recommended.
|
||||
*
|
||||
*
|
||||
* @tags stepwise
|
||||
* @returns {Pattern}
|
||||
* @example
|
||||
* zip("e f", "e f g", "g [f e] a f4 c").note()
|
||||
* .sound("folkharp")
|
||||
* .pace(8)
|
||||
.sound("folkharp")
|
||||
.pace(8)
|
||||
*/
|
||||
export const zip = function (...pats) {
|
||||
pats = pats.filter((pat) => pat.hasSteps);
|
||||
@@ -4008,9 +3667,9 @@ export const slice = register(
|
||||
* s("bd!8").onTriggerTime((hap) => {console.log(hap)})
|
||||
*/
|
||||
Pattern.prototype.onTriggerTime = function (func) {
|
||||
return this.onSchedule((hap, targetTime) => {
|
||||
const diff = targetTime - getClockTime();
|
||||
setTimeout(() => {
|
||||
return this.onTrigger((hap, currentTime, _cps, targetTime) => {
|
||||
const diff = targetTime - currentTime;
|
||||
window.setTimeout(() => {
|
||||
func(hap);
|
||||
}, diff * 1000);
|
||||
}, false);
|
||||
|
||||
@@ -104,8 +104,6 @@ export const pickmodF = register('pickmodF', function (pickPattern, lookup, pat)
|
||||
* @param {Pattern} pat
|
||||
* @param {*} xs
|
||||
* @returns {Pattern}
|
||||
* @example
|
||||
* note("<0*4 1 2*2 3*3>".pickOut(["g a", "e f", "f g f g" , "g c d"]))
|
||||
*/
|
||||
export const pickOut = register('pickOut', function (lookup, pat) {
|
||||
return _pick(lookup, pat, false).outerJoin();
|
||||
|
||||
+14
-21
@@ -7,15 +7,13 @@ import {
|
||||
setIsStarted,
|
||||
setPattern as exposeSchedulerPattern,
|
||||
setTime,
|
||||
setScheduleFunc,
|
||||
setClockTime,
|
||||
setTriggerFunc,
|
||||
} from './schedulerState.mjs';
|
||||
import { evalScope } from './evaluate.mjs';
|
||||
import { register, Pattern, isPattern, silence, stack } from './pattern.mjs';
|
||||
import { reset_state } from './impure.mjs';
|
||||
|
||||
export function repl({
|
||||
onSchedule,
|
||||
defaultOutput,
|
||||
onEvalError,
|
||||
beforeEval,
|
||||
@@ -32,11 +30,6 @@ export function repl({
|
||||
id,
|
||||
mondo = false,
|
||||
}) {
|
||||
if (defaultOutput) {
|
||||
throw new Error(
|
||||
'defaultOutput has been removed. use onSchedule(hap, time, cps) instead. see https://codeberg.org/uzu/strudel/pulls/2138/',
|
||||
);
|
||||
}
|
||||
const state = {
|
||||
schedulerError: undefined,
|
||||
evalError: undefined,
|
||||
@@ -62,7 +55,7 @@ export function repl({
|
||||
};
|
||||
|
||||
const schedulerOptions = {
|
||||
onSchedule: getSchedule({ onSchedule }),
|
||||
onTrigger: getTrigger({ defaultOutput, getTime }),
|
||||
getTime,
|
||||
onToggle: (started) => {
|
||||
updateState({ started });
|
||||
@@ -80,7 +73,7 @@ export function repl({
|
||||
// NeoCyclist uses a shared worker to communicate between instances, which is not supported on mobile chrome
|
||||
const scheduler =
|
||||
sync && typeof SharedWorker != 'undefined' ? new NeoCyclist(schedulerOptions) : new Cyclist(schedulerOptions);
|
||||
setScheduleFunc(schedulerOptions.onSchedule);
|
||||
setTriggerFunc(schedulerOptions.onTrigger);
|
||||
setCpsFunc(() => scheduler.cps);
|
||||
let pPatterns = {};
|
||||
let anonymousIndex = 0;
|
||||
@@ -231,7 +224,6 @@ export function repl({
|
||||
return pattern;
|
||||
};
|
||||
setTime(() => scheduler.now()); // TODO: refactor?
|
||||
setClockTime(() => scheduler.getTime()); // TODO: refactor?
|
||||
|
||||
// Helper function to apply pattern transformations (solo, each, all)
|
||||
// this should be abstracted more
|
||||
@@ -415,7 +407,6 @@ export function repl({
|
||||
updateState({ code, pending: true });
|
||||
await injectPatternMethods();
|
||||
setTime(() => scheduler.now()); // TODO: refactor?
|
||||
setClockTime(() => scheduler.getTime()); // TODO: refactor?
|
||||
await beforeEval?.({ code, blockBased: false });
|
||||
allTransforms = []; // reset all transforms
|
||||
|
||||
@@ -461,7 +452,6 @@ export function repl({
|
||||
updateState({ code, pending: true });
|
||||
await injectPatternMethods();
|
||||
setTime(() => scheduler.now()); // TODO: refactor?
|
||||
setClockTime(() => scheduler.getTime()); // TODO: refactor?
|
||||
await beforeEval?.({ code, blockBased: true });
|
||||
allTransforms = []; // reset all transforms
|
||||
|
||||
@@ -570,17 +560,20 @@ export function repl({
|
||||
return { scheduler, evaluate, evaluateBlock, start, stop, pause, setCps, setPattern, setCode, toggle, state };
|
||||
}
|
||||
|
||||
export const getSchedule =
|
||||
({ onSchedule }) =>
|
||||
async (hap, t, cps) => {
|
||||
export const getTrigger =
|
||||
({ getTime, defaultOutput }) =>
|
||||
async (hap, deadline, duration, cps, t) => {
|
||||
// ^ this signature is different from hap.context.onTrigger, as set by Pattern.onTrigger(onTrigger)
|
||||
// TODO: get rid of deadline after https://codeberg.org/uzu/strudel/pulls/1004
|
||||
try {
|
||||
if (!hap.context.onSchedule || !hap.context.dominantSchedule) {
|
||||
await onSchedule(hap, t, cps);
|
||||
if (!hap.context.onTrigger || !hap.context.dominantTrigger) {
|
||||
await defaultOutput(hap, deadline, duration, cps, t);
|
||||
}
|
||||
if (hap.context.onSchedule) {
|
||||
await hap.context.onSchedule(hap, t, cps);
|
||||
if (hap.context.onTrigger) {
|
||||
// call signature of output / onTrigger is different...
|
||||
await hap.context.onTrigger(hap, getTime(), cps, t);
|
||||
}
|
||||
} catch (err) {
|
||||
errorLogger(err, 'getSchedule');
|
||||
errorLogger(err, 'getTrigger');
|
||||
}
|
||||
};
|
||||
|
||||
@@ -7,14 +7,8 @@ This program is free software: you can redistribute it and/or modify it under th
|
||||
let time;
|
||||
let cpsFunc;
|
||||
let pattern;
|
||||
let scheduleFunc;
|
||||
let triggerFunc;
|
||||
let isStarted;
|
||||
|
||||
/**
|
||||
* @name getTime
|
||||
* @tags internals
|
||||
* @returns {Number} the current cycle time as a number
|
||||
*/
|
||||
export function getTime() {
|
||||
if (!time) {
|
||||
throw new Error('no time set! use setTime to define a time source');
|
||||
@@ -26,32 +20,10 @@ export function setTime(func) {
|
||||
time = func;
|
||||
}
|
||||
|
||||
let clockTime;
|
||||
/**
|
||||
* @name getClockTime
|
||||
* @tags internals
|
||||
* @returns {Number} the current clock time in seconds (onSchedule time)
|
||||
*/
|
||||
export function getClockTime() {
|
||||
if (!clockTime) {
|
||||
throw new Error('no clockTime set! use setClockTime to define a time source');
|
||||
}
|
||||
return clockTime();
|
||||
}
|
||||
|
||||
export function setClockTime(func) {
|
||||
clockTime = func;
|
||||
}
|
||||
|
||||
export function setCpsFunc(func) {
|
||||
cpsFunc = func;
|
||||
}
|
||||
|
||||
/**
|
||||
* @name getCps
|
||||
* @tags internals
|
||||
* @returns {Number} the current cycles per second
|
||||
*/
|
||||
export function getCps() {
|
||||
return cpsFunc?.();
|
||||
}
|
||||
@@ -64,12 +36,12 @@ export function getPattern() {
|
||||
return pattern;
|
||||
}
|
||||
|
||||
export function setScheduleFunc(func) {
|
||||
scheduleFunc = func;
|
||||
export function setTriggerFunc(func) {
|
||||
triggerFunc = func;
|
||||
}
|
||||
|
||||
export function getScheduleFunc() {
|
||||
return scheduleFunc;
|
||||
export function getTriggerFunc() {
|
||||
return triggerFunc;
|
||||
}
|
||||
|
||||
export function setIsStarted(val) {
|
||||
|
||||
+13
-76
@@ -5,8 +5,7 @@ This program is free software: you can redistribute it and/or modify it under th
|
||||
*/
|
||||
|
||||
import { Hap } from './hap.mjs';
|
||||
import { Pattern, fastcat, pure, register, reify, silence, stack, sequenceP, isPattern } from './pattern.mjs';
|
||||
import { _mod } from './util.mjs';
|
||||
import { Pattern, fastcat, pure, register, reify, silence, stack, sequenceP } from './pattern.mjs';
|
||||
import Fraction from './fraction.mjs';
|
||||
|
||||
import { id, keyAlias, getCurrentKeyboardState } from './util.mjs';
|
||||
@@ -16,24 +15,6 @@ export function steady(value) {
|
||||
return new Pattern((state) => [new Hap(undefined, state.span, value)]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a signal given by the input function
|
||||
*
|
||||
* @name signal
|
||||
* @param {*} func
|
||||
* @returns {Pattern} signal
|
||||
* @tags generators
|
||||
* @example
|
||||
* // sawtooth signal definition
|
||||
* signal(t=>t%1).segment(16).range(30,40).note()
|
||||
* @example
|
||||
* signal(t=>Math.pow(t,2)%1).range(40, 60).add(5).segment(16)
|
||||
* .off(0, x=>x.add(7))
|
||||
* .note()
|
||||
* .s("gm_electric_guitar_jazz,gm_epiano")
|
||||
* .gain(1.7)
|
||||
* .pianoroll()
|
||||
*/
|
||||
export const signal = (func) => {
|
||||
const query = (state) => [new Hap(undefined, state.span, func(state.span.begin, state.controls))];
|
||||
return new Pattern(query);
|
||||
@@ -52,7 +33,7 @@ export const signal = (func) => {
|
||||
* .scale('C major')
|
||||
*
|
||||
*/
|
||||
export const saw = signal((t) => _mod(t, 1));
|
||||
export const saw = signal((t) => t % 1);
|
||||
|
||||
/**
|
||||
* A sawtooth signal between -1 and 1 (like `saw`, but bipolar).
|
||||
@@ -75,7 +56,7 @@ export const saw2 = saw.toBipolar();
|
||||
* .scale('C major')
|
||||
*
|
||||
*/
|
||||
export const isaw = signal((t) => 1 - _mod(t, 1));
|
||||
export const isaw = signal((t) => 1 - (t % 1));
|
||||
|
||||
/**
|
||||
* A sawtooth signal between 1 and -1 (like `saw2`, but flipped).
|
||||
@@ -132,7 +113,7 @@ export const cosine2 = sine2._early(Fraction(1).div(4));
|
||||
* n(square.segment(4).range(0,7)).scale("C:minor")
|
||||
*
|
||||
*/
|
||||
export const square = signal((t) => Math.floor(_mod(t * 2, 2)));
|
||||
export const square = signal((t) => Math.floor((t * 2) % 2));
|
||||
|
||||
/**
|
||||
* A square signal between -1 and 1 (like `square`, but bipolar).
|
||||
@@ -142,22 +123,6 @@ export const square = signal((t) => Math.floor(_mod(t * 2, 2)));
|
||||
*/
|
||||
export const square2 = square.toBipolar();
|
||||
|
||||
/**
|
||||
* A square signal between 1 and 0 (like `square` but flipped).
|
||||
*
|
||||
* @return {Pattern}
|
||||
* @tags generators
|
||||
*/
|
||||
export const isquare = signal((t) => 1 - Math.floor(_mod(t * 2, 2)));
|
||||
|
||||
/**
|
||||
* A square signal between 1 and -1 (like `isquare`, but bipolar).
|
||||
*
|
||||
* @return {Pattern}
|
||||
* @tags generators
|
||||
*/
|
||||
export const isquare2 = isquare.toBipolar();
|
||||
|
||||
/**
|
||||
* A triangle signal between 0 and 1.
|
||||
*
|
||||
@@ -207,7 +172,6 @@ export const time = signal(id);
|
||||
/**
|
||||
* The mouse's x position value ranges from 0 to 1.
|
||||
* @name mousex
|
||||
* @synonyms mouseX
|
||||
* @return {Pattern}
|
||||
* @tags external_io
|
||||
* @example
|
||||
@@ -218,7 +182,6 @@ export const time = signal(id);
|
||||
/**
|
||||
* The mouse's y position value ranges from 0 to 1.
|
||||
* @name mousey
|
||||
* @synonyms mouseY
|
||||
* @return {Pattern}
|
||||
* @tags external_io
|
||||
* @example
|
||||
@@ -433,7 +396,7 @@ export const randrun = (n) => {
|
||||
.map((n, i) => [n, i])
|
||||
.sort((a, b) => (a[0] > b[0]) - (a[0] < b[0]))
|
||||
.map((x) => x[1]);
|
||||
const i = _mod(t.cyclePos().mul(n).floor(), n);
|
||||
const i = t.cyclePos().mul(n).floor() % n;
|
||||
return nums[i];
|
||||
})._segment(n);
|
||||
};
|
||||
@@ -579,9 +542,6 @@ export const __chooseWith = (pat, xs) => {
|
||||
* @returns {Pattern}
|
||||
* @example
|
||||
* note("c2 g2!2 d2 f1").s(chooseWith(sine.fast(2), ["sawtooth", "triangle", "bd:6"]))
|
||||
* @example
|
||||
* // Compare with chooseInWith
|
||||
* note(chooseWith("<0 0.5 1>*3", ["c3", "b3", "d3"]))
|
||||
*/
|
||||
export const chooseWith = (pat, xs) => {
|
||||
return __chooseWith(pat, xs).outerJoin();
|
||||
@@ -593,13 +553,6 @@ export const chooseWith = (pat, xs) => {
|
||||
* @tags temporal
|
||||
* @param {Pattern} pat
|
||||
* @param {*} xs
|
||||
* @example
|
||||
* // Because the structure comes from the chosen values (the notes, here)
|
||||
* // The choosing pattern will only advance once per cycle (not 3 times per cycle)
|
||||
* note(chooseInWith("<0 0.5 1>*3", ["c3", "b3", "d3"]))
|
||||
* @example
|
||||
* // Here, the chosen values have a structure such that the choosing pattern will advance 3 times per cycle
|
||||
* note(chooseInWith("<0 0.5 1>*3", ["c3*3", "b3*3", "d3*3"]))
|
||||
* @returns {Pattern}
|
||||
*/
|
||||
export const chooseInWith = (pat, xs) => {
|
||||
@@ -616,7 +569,9 @@ export const chooseInWith = (pat, xs) => {
|
||||
*/
|
||||
export const choose = (...xs) => chooseWith(rand, xs);
|
||||
|
||||
// todo: doc
|
||||
export const chooseIn = (...xs) => chooseInWith(rand, xs);
|
||||
export const chooseOut = choose;
|
||||
|
||||
/**
|
||||
* Chooses from the given list of values (or patterns of values), according
|
||||
@@ -762,30 +717,12 @@ export const perlin = signal((t, controls) => _perlin(t, controls.randSeed));
|
||||
*/
|
||||
export const berlin = signal((t, controls) => _berlin(t, controls.randSeed));
|
||||
|
||||
/**
|
||||
* `degradeByWith` is like `degradeBy`, but with control over the random or other signal used to filter out the events.
|
||||
*
|
||||
* `degradeBy(x)` is essentially `degradeByWith(rand, x)`
|
||||
*
|
||||
* This allows you to do things other than with `rand`, see examples below
|
||||
*
|
||||
* @name degradeByWith
|
||||
* @param {Pattern|number} test
|
||||
* @param {Pattern|number} testAgainst
|
||||
* @memberof Pattern
|
||||
* @tags temporal
|
||||
* @returns {Pattern}
|
||||
* @example
|
||||
* note("c a f e").degradeByWith(sine, .1)
|
||||
* @example
|
||||
* note("c a f e").degradeByWith(perlin, .5)
|
||||
* @example
|
||||
* note("c a f e").degradeByWith(sine, cosine)
|
||||
*/
|
||||
export const degradeByWith = register('degradeByWith', (withPat, x, pat) => {
|
||||
if (!isPattern(withPat)) withPat = pure(withPat);
|
||||
return pat.fmap((a) => (_) => a).appLeft(withPat.filterValues((v) => v > x));
|
||||
});
|
||||
export const degradeByWith = register(
|
||||
'degradeByWith',
|
||||
(withPat, x, pat) => pat.fmap((a) => (_) => a).appLeft(withPat.filterValues((v) => v > x)),
|
||||
true,
|
||||
true,
|
||||
);
|
||||
|
||||
/**
|
||||
* Randomly removes events from the pattern by a given amount.
|
||||
|
||||
@@ -32,7 +32,7 @@ function triggerSpeech(words, lang, voice) {
|
||||
}
|
||||
|
||||
export const speak = register('speak', function (lang, voice, pat) {
|
||||
return pat.onSchedule((hap) => {
|
||||
return pat.onTrigger((hap) => {
|
||||
triggerSpeech(hap.value, lang, voice);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -29,44 +29,6 @@ describe('euclid', () => {
|
||||
.map((a) => a.showWhole(true)),
|
||||
).toStrictEqual(['0/1 → 1/8: a', '1/4 → 3/8: a', '3/8 → 1/2: a', '5/8 → 3/4: a', '3/4 → 7/8: a']);
|
||||
});
|
||||
it('Can create euclidLegato using negative steps', () => {
|
||||
expect(
|
||||
fastcat('a')
|
||||
.euclid(3, -8)
|
||||
.firstCycle()
|
||||
.sort((a, b) => a.part.begin.sub(b.part.begin))
|
||||
.map((a) => a.showWhole(true)),
|
||||
).toStrictEqual(
|
||||
fastcat('a')
|
||||
.euclidLegato(3, 8)
|
||||
.firstCycle()
|
||||
.sort((a, b) => a.part.begin.sub(b.part.begin))
|
||||
.map((a) => a.showWhole(true)),
|
||||
);
|
||||
expect(
|
||||
fastcat('a')
|
||||
.euclid(5, -8)
|
||||
.firstCycle()
|
||||
.sort((a, b) => a.part.begin.sub(b.part.begin))
|
||||
.map((a) => a.showWhole(true)),
|
||||
).toStrictEqual(
|
||||
fastcat('a')
|
||||
.euclidLegato(5, 8)
|
||||
.firstCycle()
|
||||
.sort((a, b) => a.part.begin.sub(b.part.begin))
|
||||
.map((a) => a.showWhole(true)),
|
||||
);
|
||||
});
|
||||
it('stretches over multiple cycles if pulses is greater than steps', () => {
|
||||
expect(
|
||||
fastcat('a')
|
||||
.euclid(5, 4)
|
||||
.fast(2)
|
||||
.firstCycle()
|
||||
.sort((a, b) => a.part.begin.sub(b.part.begin))
|
||||
.map((a) => a.showWhole(true)),
|
||||
).toStrictEqual(['0/1 → 1/8: a', '1/4 → 3/8: a', '3/8 → 1/2: a', '5/8 → 3/4: a', '3/4 → 7/8: a']);
|
||||
});
|
||||
});
|
||||
|
||||
describe('euclidRot', () => {
|
||||
@@ -105,45 +67,6 @@ describe('euclidLegato', () => {
|
||||
.map((a) => a.showWhole(true)),
|
||||
).toStrictEqual(['0/1 → 1/4: a', '1/4 → 3/8: a', '3/8 → 5/8: a', '5/8 → 3/4: a', '3/4 → 1/1: a']);
|
||||
});
|
||||
it('Can create euclid using negative steps', () => {
|
||||
expect(
|
||||
fastcat('a')
|
||||
.euclidLegato(3, -8)
|
||||
.firstCycle()
|
||||
.sort((a, b) => a.part.begin.sub(b.part.begin))
|
||||
.map((a) => a.showWhole(true)),
|
||||
).toStrictEqual(
|
||||
fastcat('a')
|
||||
.euclid(3, 8)
|
||||
.firstCycle()
|
||||
.sort((a, b) => a.part.begin.sub(b.part.begin))
|
||||
.map((a) => a.showWhole(true)),
|
||||
);
|
||||
expect(
|
||||
fastcat('a')
|
||||
.euclidLegato(5, -8)
|
||||
.firstCycle()
|
||||
.sort((a, b) => a.part.begin.sub(b.part.begin))
|
||||
.map((a) => a.showWhole(true)),
|
||||
).toStrictEqual(
|
||||
fastcat('a')
|
||||
.euclid(5, 8)
|
||||
.firstCycle()
|
||||
.sort((a, b) => a.part.begin.sub(b.part.begin))
|
||||
.map((a) => a.showWhole(true)),
|
||||
);
|
||||
});
|
||||
it('stretches over multiple cycles if pulses is greater than steps', () => {
|
||||
expect(
|
||||
fastcat('a')
|
||||
.euclidLegato(5, 4)
|
||||
.fast(2)
|
||||
.firstCycle()
|
||||
.filter((hap) => hap.hasOnset())
|
||||
.sort((a, b) => a.part.begin.sub(b.part.begin))
|
||||
.map((a) => a.showWhole(true)),
|
||||
).toStrictEqual(['0/1 → 1/4: a', '1/4 → 3/8: a', '3/8 → 5/8: a', '5/8 → 3/4: a', '3/4 → 1/1: a']);
|
||||
});
|
||||
});
|
||||
|
||||
describe('euclidLegatoRot', () => {
|
||||
|
||||
@@ -18,7 +18,6 @@ import {
|
||||
fastcat,
|
||||
firstOf,
|
||||
slowcat,
|
||||
slowcatPrime,
|
||||
cat,
|
||||
sequence,
|
||||
palindrome,
|
||||
@@ -46,7 +45,6 @@ import {
|
||||
rev,
|
||||
time,
|
||||
run,
|
||||
randrun,
|
||||
binaryN,
|
||||
pick,
|
||||
stackLeft,
|
||||
@@ -55,10 +53,9 @@ import {
|
||||
stepcat,
|
||||
sometimes,
|
||||
expand,
|
||||
arp,
|
||||
} from '../index.mjs';
|
||||
|
||||
import { log, logValues, stackCenter } from '../pattern.mjs';
|
||||
import { log, logValues } from '../pattern.mjs';
|
||||
|
||||
import { steady } from '../signal.mjs';
|
||||
|
||||
@@ -75,10 +72,6 @@ const sameFirst = (a, b) => {
|
||||
return expect(a.sortHapsByPart().firstCycle()).toStrictEqual(b.sortHapsByPart().firstCycle());
|
||||
};
|
||||
|
||||
const sameFirstX = (x, a, b) => {
|
||||
return expect(a.fast(x).sortHapsByPart().firstCycle()).toStrictEqual(b.fast(x).sortHapsByPart().firstCycle());
|
||||
};
|
||||
|
||||
describe('TimeSpan', () => {
|
||||
describe('equals()', () => {
|
||||
it('Should be equal to the same value', () => {
|
||||
@@ -551,9 +544,6 @@ describe('Pattern', () => {
|
||||
});
|
||||
});
|
||||
describe('slowcat()', () => {
|
||||
it('Can be empty', () => {
|
||||
expect(slowcat().firstCycle()).toStrictEqual([]);
|
||||
});
|
||||
it('Can concatenate things slowly', () => {
|
||||
expect(
|
||||
slowcat('a', 'b')
|
||||
@@ -586,38 +576,6 @@ describe('Pattern', () => {
|
||||
sameFirst(slowcat('a', ['b', 'c']).fast(4), sequence('a', ['b', 'c']).fast(2));
|
||||
});
|
||||
});
|
||||
describe('slowcatPrime()', () => {
|
||||
it('Can be empty', () => {
|
||||
expect(slowcatPrime().firstCycle()).toStrictEqual([]);
|
||||
});
|
||||
it('Can slowcat patterns swapping back and forth skipping the expected notes', () => {
|
||||
expect(
|
||||
slowcatPrime(fastcat(0, 1, 2, 3).slow(2), fastcat(4, 5, 6, 7).slow(2))
|
||||
.fast(4)
|
||||
.firstCycle()
|
||||
.map((a) => a.value),
|
||||
).toStrictEqual([0, 1, 6, 7, 0, 1, 6, 7]);
|
||||
});
|
||||
it('Can go into negative time', () => {
|
||||
expect(
|
||||
slowcatPrime(fastcat(0, 1, 2, 3).slow(2), fastcat(4, 5, 6, 7).slow(2))
|
||||
.fast(4)
|
||||
.late(8)
|
||||
.firstCycle()
|
||||
.map((a) => a.value),
|
||||
).toStrictEqual([0, 1, 6, 7, 0, 1, 6, 7]);
|
||||
});
|
||||
});
|
||||
describe('arp()', () => {
|
||||
it('It wraps around with both positive and negative indices', () => {
|
||||
expect(
|
||||
stack('a', 'b', 'c')
|
||||
.arp(fastcat(-3, -2, -1, 0, 1, 2, 3, 4))
|
||||
.firstCycle()
|
||||
.map((a) => a.value),
|
||||
).toStrictEqual(['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b']);
|
||||
});
|
||||
});
|
||||
describe('rev()', () => {
|
||||
it('Can reverse things', () => {
|
||||
expect(
|
||||
@@ -987,17 +945,6 @@ describe('Pattern', () => {
|
||||
it('Can run', () => {
|
||||
expect(run(4).firstCycle()).toStrictEqual(sequence(0, 1, 2, 3).firstCycle());
|
||||
});
|
||||
it('Can go into negative time', () => {
|
||||
expect(run(4).late(1).firstCycle()).toStrictEqual(sequence(0, 1, 2, 3).firstCycle());
|
||||
});
|
||||
});
|
||||
describe('randrun', () => {
|
||||
it('Can randrun', () => {
|
||||
expect(randrun(4).firstCycle()).toStrictEqual(sequence(2, 1, 3, 0).firstCycle());
|
||||
});
|
||||
it('Can go into negative time', () => {
|
||||
expect(randrun(4).late(1).firstCycle()).toStrictEqual(sequence(1, 2, 0, 3).firstCycle());
|
||||
});
|
||||
});
|
||||
describe('binaryN', () => {
|
||||
it('Can make a binary pattern from a decimal', () => {
|
||||
@@ -1219,7 +1166,6 @@ describe('Pattern', () => {
|
||||
expect(stackRight(fastcat(0, 1, 2), fastcat(3, 4))._steps).toStrictEqual(Fraction(3));
|
||||
// maybe this should double when they are either all even or all odd
|
||||
expect(stackCentre(fastcat(0, 1, 2), fastcat(3, 4))._steps).toStrictEqual(Fraction(3));
|
||||
expect(stackCenter(fastcat(0, 1, 2), fastcat(3, 4))._steps).toStrictEqual(Fraction(3));
|
||||
expect(fastcat(0, 1).ply(3)._steps).toStrictEqual(Fraction(6));
|
||||
expect(fastcat(0, 1).setSteps(undefined).ply(3)._steps).toStrictEqual(undefined);
|
||||
expect(fastcat(0, 1).fast(3)._steps).toStrictEqual(Fraction(2));
|
||||
@@ -1325,21 +1271,6 @@ describe('Pattern', () => {
|
||||
);
|
||||
});
|
||||
});
|
||||
describe('isobite', () => {
|
||||
it('can play a melody with a structure', () => {
|
||||
sameFirst(
|
||||
slowcat(0, 1, 2, 3, 4, 5).isobite(fastcat(true, silence, [true, true]).fast(2)),
|
||||
fastcat(0, silence, [1, 2], 3, silence, [4, 5]),
|
||||
);
|
||||
});
|
||||
it('syncopates over multiple cycles if the number of haps in the patterns differ', () => {
|
||||
sameFirstX(
|
||||
4,
|
||||
slowcat(0, 1, 2, 3).isobite(fastcat(true, [true, true])),
|
||||
slowcat(0, [1, 2], 3, [0, 1], 2, [3, 0], 1, [2, 3]).fast(2),
|
||||
);
|
||||
});
|
||||
});
|
||||
describe('unjoin', () => {
|
||||
it('destructures a pattern into subcycles', () => {
|
||||
sameFirst(
|
||||
@@ -1383,7 +1314,7 @@ describe('Pattern', () => {
|
||||
|
||||
// Force a trigger
|
||||
haps.forEach((hap) => {
|
||||
hap.context?.onSchedule?.(hap);
|
||||
hap.context?.onTrigger?.(hap);
|
||||
});
|
||||
|
||||
expect(mockConsoleLog).toHaveBeenCalledWith(
|
||||
@@ -1401,7 +1332,7 @@ describe('Pattern', () => {
|
||||
|
||||
// Force a trigger
|
||||
haps.forEach((hap) => {
|
||||
hap.context?.onSchedule?.(hap);
|
||||
hap.context?.onTrigger?.(hap);
|
||||
});
|
||||
|
||||
expect(mockConsoleLog).toHaveBeenCalledWith(
|
||||
|
||||
@@ -8,23 +8,7 @@ import Fraction from 'fraction.js';
|
||||
|
||||
import { describe, it, expect, vi } from 'vitest';
|
||||
|
||||
import {
|
||||
saw,
|
||||
saw2,
|
||||
isaw,
|
||||
isaw2,
|
||||
tri,
|
||||
tri2,
|
||||
itri,
|
||||
itri2,
|
||||
square,
|
||||
square2,
|
||||
isquare,
|
||||
isquare2,
|
||||
per,
|
||||
perx,
|
||||
cyclesPer,
|
||||
} from '../signal.mjs';
|
||||
import { saw, saw2, isaw, isaw2, per, perx, cyclesPer } from '../signal.mjs';
|
||||
import { fastcat, sequence, State, TimeSpan, Hap, note } from '../index.mjs';
|
||||
|
||||
const st = (begin, end) => new State(ts(begin, end));
|
||||
@@ -40,61 +24,17 @@ const sameFirst = (a, b) => {
|
||||
|
||||
describe('signal()', () => {
|
||||
it('Can make saw/saw2', () => {
|
||||
expect(saw.struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(0, 0.25, 0.5, 0.75).firstCycle());
|
||||
expect(saw.struct(true, true, true, true).firstCycle()).toStrictEqual(
|
||||
sequence(0, 1 / 4, 1 / 2, 3 / 4).firstCycle(),
|
||||
);
|
||||
|
||||
expect(saw2.struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(-1, -0.5, 0, 0.5).firstCycle());
|
||||
});
|
||||
it('Can make isaw/isaw2', () => {
|
||||
expect(isaw.struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(1, 0.75, 0.5, 0.25).firstCycle());
|
||||
|
||||
expect(isaw2.struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(1, 0.5, 0, -0.5).firstCycle());
|
||||
});
|
||||
it('Can make tri/tri2', () => {
|
||||
expect(tri.struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(0, 0.5, 1, 0.5).firstCycle());
|
||||
expect(tri2.struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(-1, 0, 1, 0).firstCycle());
|
||||
});
|
||||
it('Can make itri/itri2', () => {
|
||||
expect(itri.struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(1, 0.5, 0, 0.5).firstCycle());
|
||||
expect(itri2.struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(1, 0, -1, 0).firstCycle());
|
||||
});
|
||||
it('Can make square/square2', () => {
|
||||
expect(square.struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(0, 0, 1, 1).firstCycle());
|
||||
expect(square2.struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(-1, -1, 1, 1).firstCycle());
|
||||
});
|
||||
it('Can make isquare/isquare2', () => {
|
||||
expect(isquare.struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(1, 1, 0, 0).firstCycle());
|
||||
expect(isquare2.struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(1, 1, -1, -1).firstCycle());
|
||||
});
|
||||
it('Can go into negative time', () => {
|
||||
expect(saw.late(1).struct(true, true, true, true).firstCycle()).toStrictEqual(
|
||||
sequence(0, 0.25, 0.5, 0.75).firstCycle(),
|
||||
);
|
||||
expect(saw2.late(1).struct(true, true, true, true).firstCycle()).toStrictEqual(
|
||||
sequence(-1, -0.5, 0, 0.5).firstCycle(),
|
||||
);
|
||||
expect(isaw.late(1).struct(true, true, true, true).firstCycle()).toStrictEqual(
|
||||
sequence(1, 0.75, 0.5, 0.25).firstCycle(),
|
||||
);
|
||||
expect(isaw2.late(1).struct(true, true, true, true).firstCycle()).toStrictEqual(
|
||||
sequence(1, 0.5, 0, -0.5).firstCycle(),
|
||||
);
|
||||
expect(tri.late(1).struct(true, true, true, true).firstCycle()).toStrictEqual(
|
||||
sequence(0, 0.5, 1, 0.5).firstCycle(),
|
||||
);
|
||||
expect(tri2.late(1).struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(-1, 0, 1, 0).firstCycle());
|
||||
expect(itri.late(1).struct(true, true, true, true).firstCycle()).toStrictEqual(
|
||||
sequence(1, 0.5, 0, 0.5).firstCycle(),
|
||||
);
|
||||
expect(itri2.late(1).struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(1, 0, -1, 0).firstCycle());
|
||||
expect(square.late(1).struct(true, true, true, true).firstCycle()).toStrictEqual(sequence(0, 0, 1, 1).firstCycle());
|
||||
expect(square2.late(1).struct(true, true, true, true).firstCycle()).toStrictEqual(
|
||||
sequence(-1, -1, 1, 1).firstCycle(),
|
||||
);
|
||||
expect(isquare.late(1).struct(true, true, true, true).firstCycle()).toStrictEqual(
|
||||
sequence(1, 1, 0, 0).firstCycle(),
|
||||
);
|
||||
expect(isquare2.late(1).struct(true, true, true, true).firstCycle()).toStrictEqual(
|
||||
sequence(1, 1, -1, -1).firstCycle(),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('cyclesPer', () => {
|
||||
|
||||
+15
-29
@@ -70,6 +70,17 @@ export const getEventOffsetMs = (targetTimeSeconds, currentTimeSeconds) => {
|
||||
return (targetTimeSeconds - currentTimeSeconds) * 1000;
|
||||
};
|
||||
|
||||
/**
|
||||
* @deprecated does not appear to be referenced or invoked anywhere in the codebase
|
||||
* @noAutocomplete
|
||||
*/
|
||||
export const getFreq = (noteOrMidi) => {
|
||||
if (typeof noteOrMidi === 'number') {
|
||||
return midiToFreq(noteOrMidi);
|
||||
}
|
||||
return midiToFreq(noteToMidi(noteOrMidi));
|
||||
};
|
||||
|
||||
const pcs = ['C', 'Db', 'D', 'Eb', 'E', 'F', 'Gb', 'G', 'Ab', 'A', 'Bb', 'B'];
|
||||
/**
|
||||
* @deprecated only used in workshop (first-notes)
|
||||
@@ -119,50 +130,25 @@ export const getPlayableNoteValue = (hap) => {
|
||||
return note;
|
||||
};
|
||||
|
||||
/**
|
||||
* Given a hap, returns the frequency of the note or freq, if defined
|
||||
*
|
||||
* Given a note, returns the frequency of that note
|
||||
* `getFreq('c3')`
|
||||
*
|
||||
* Given a midi note number, returns the frequency of that midi note
|
||||
* `getFreq('c3')`
|
||||
*
|
||||
* @name getFrequency
|
||||
* @tags pitch
|
||||
* @synonyms getFreq
|
||||
* @param {Hap | note | number} input
|
||||
* @returns {Number}
|
||||
* @example
|
||||
* i("4 8 9 10 - - 5 7 9 11 - -").tune("tranh3")
|
||||
* .mul(getFreq('c3'))
|
||||
* .freq().clip(.5).room(1)
|
||||
*/
|
||||
export const getFrequency = (hap) => {
|
||||
let { value, context } =
|
||||
typeof hap == 'object'
|
||||
? hap
|
||||
: // default: interpret value as midi note.
|
||||
{ value: hap, context: { type: 'note' } };
|
||||
let { value, context } = hap;
|
||||
// if value is number => interpret as midi number as long as its not marked as frequency
|
||||
if (typeof value === 'object') {
|
||||
if (value.freq) {
|
||||
return value.freq;
|
||||
}
|
||||
return getFreq(value.note ?? value.n ?? value.value);
|
||||
return getFreq(value.note || value.n || value.value);
|
||||
}
|
||||
if (typeof value === 'number' && context.type !== 'frequency') {
|
||||
value = midiToFreq(value);
|
||||
value = midiToFreq(hap.value);
|
||||
} else if (typeof value === 'string' && isNote(value)) {
|
||||
value = midiToFreq(noteToMidi(value));
|
||||
value = midiToFreq(noteToMidi(hap.value));
|
||||
} else if (typeof value !== 'number') {
|
||||
throw new Error('not a note or frequency: ' + value);
|
||||
}
|
||||
return value;
|
||||
};
|
||||
|
||||
export const getFreq = (hap) => getFrequency(hap);
|
||||
|
||||
// rotate array by n steps (to the left)
|
||||
export const rotate = (arr, n) => arr.slice(n).concat(arr.slice(0, n));
|
||||
|
||||
|
||||
@@ -23,7 +23,7 @@ export const csound = register('csound', (instrument, pat) => {
|
||||
instrument = instrument || 'triangle';
|
||||
init(); // not async to support csound inside other patterns + to be able to call pattern methods after it
|
||||
// TODO: find a alternative way to wait for csound to load (to wait with first time playback)
|
||||
return pat.onSchedule((hap, targetTime) => {
|
||||
return pat.onTrigger((hap, currentTime, _cps, targetTime) => {
|
||||
if (!_csound) {
|
||||
logger('[csound] not loaded yet', 'warning');
|
||||
return;
|
||||
@@ -36,10 +36,9 @@ export const csound = register('csound', (instrument, pat) => {
|
||||
const controls = Object.entries({ ...hap.value, freq })
|
||||
.flat()
|
||||
.join('/');
|
||||
|
||||
// TODO: find out how to send a precise ctx based time
|
||||
// http://www.csounds.com/manual/html/i.html
|
||||
const timeOffset = targetTime - getAudioContext().currentTime; // latency ?
|
||||
const timeOffset = targetTime - currentTime; // latency ?
|
||||
//const timeOffset = time_deprecate - getAudioContext().currentTime
|
||||
const params = [
|
||||
`"${instrument}"`, // p1: instrument name
|
||||
@@ -145,7 +144,7 @@ export const csoundm = register('csoundm', (instrument, pat) => {
|
||||
p1 = `"${instrument}"`;
|
||||
}
|
||||
init(); // not async to support csound inside other patterns + to be able to call pattern methods after it
|
||||
return pat.onSchedule((hap, targetTime) => {
|
||||
return pat.onTrigger((hap, currentTime, _cps, targetTime) => {
|
||||
if (!_csound) {
|
||||
logger('[csound] not loaded yet', 'warning');
|
||||
return;
|
||||
@@ -153,7 +152,6 @@ export const csoundm = register('csoundm', (instrument, pat) => {
|
||||
if (typeof hap.value !== 'object') {
|
||||
throw new Error('csound only support objects as hap values');
|
||||
}
|
||||
const currentTime = getAudioContext().currentTime;
|
||||
// Time in seconds counting from now.
|
||||
const p2 = targetTime - currentTime;
|
||||
const p3 = hap.duration.valueOf() + 0;
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
import { getAudioContext } from '@strudel/webaudio/index.mjs';
|
||||
import { Invoke } from './utils.mjs';
|
||||
import { Pattern, getEventOffsetMs, noteToMidi } from '@strudel/core';
|
||||
|
||||
@@ -7,8 +6,7 @@ const OFF_MESSAGE = 0x80;
|
||||
const CC_MESSAGE = 0xb0;
|
||||
|
||||
Pattern.prototype.midi = function (output) {
|
||||
return this.onSchedule((hap, targetTime, cps) => {
|
||||
const currentTime = getAudioContext().currentTime;
|
||||
return this.onTrigger((hap, currentTime, cps, targetTime) => {
|
||||
let { note, nrpnn, nrpv, ccn, ccv, velocity = 0.9, gain = 1 } = hap.value;
|
||||
//magic number to get audio engine to line up, can probably be calculated somehow
|
||||
const latencyMs = 34;
|
||||
|
||||
@@ -1,14 +1,12 @@
|
||||
import { Pattern, ClockCollator } from '@strudel/core';
|
||||
import { parseControlsFromHap } from '@strudel/osc/osc.mjs';
|
||||
import { parseControlsFromHap } from 'node_modules/@strudel/osc/osc.mjs';
|
||||
import { Invoke } from './utils.mjs';
|
||||
import { getAudioContext } from '@strudel/webaudio/index.mjs';
|
||||
|
||||
const collator = new ClockCollator({});
|
||||
|
||||
export async function tauriOscOutput(hap, targetTime, cps = 1) {
|
||||
export async function oscTriggerTauri(hap, currentTime, cps = 1, targetTime) {
|
||||
const controls = parseControlsFromHap(hap, cps);
|
||||
const params = [];
|
||||
const currentTime = getAudioContext().currentTime;
|
||||
const timestamp = collator.calculateTimestamp(currentTime, targetTime);
|
||||
|
||||
Object.keys(controls).forEach((key) => {
|
||||
@@ -34,5 +32,5 @@ export async function tauriOscOutput(hap, targetTime, cps = 1) {
|
||||
});
|
||||
}
|
||||
Pattern.prototype.osc = function () {
|
||||
return this.onSchedule(tauriOscOutput);
|
||||
return this.onTrigger(oscTriggerTauri);
|
||||
};
|
||||
|
||||
@@ -23,8 +23,6 @@
|
||||
},
|
||||
"dependencies": {
|
||||
"@strudel/core": "workspace:*",
|
||||
"@strudel/osc": "workspace:*",
|
||||
"@strudel/webaudio": "workspace:*",
|
||||
"@tauri-apps/api": "^2.2.0"
|
||||
},
|
||||
"homepage": "https://codeberg.org/uzu/strudel#readme",
|
||||
|
||||
@@ -1,75 +0,0 @@
|
||||
/*
|
||||
dough.mjs
|
||||
Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/osc/osc.mjs>
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
import { register, noteToMidi } from '@strudel/core';
|
||||
import { Dough, doughsamples } from 'dough-synth';
|
||||
import { getAudioContext, ensureMinimalOutput } from '@strudel/webaudio';
|
||||
import wasm from 'dough-synth/dough.wasm?url';
|
||||
import workletCode from 'dough-synth/dough.js?raw';
|
||||
|
||||
Object.assign(globalThis, { doughsamples });
|
||||
|
||||
let D;
|
||||
/**
|
||||
*
|
||||
* initializes dough ahead of time. you don't need to use this, but if you do, you can await it, so dough is ready before the pattern starts.
|
||||
*
|
||||
* @name initDough
|
||||
* @tags external_io
|
||||
* @memberof Pattern
|
||||
* @example
|
||||
* await initDough()
|
||||
* $: chord("<Dm9 Dm11 Dm7>").offset("<-1 0 1 0>").voicing()
|
||||
* .phaser(3).fm(1.4).fmh(1.01)
|
||||
* .dough()
|
||||
*/
|
||||
export function initDough() {
|
||||
if (!D || D.audioContext !== getAudioContext()) {
|
||||
D = new Dough({
|
||||
wasm,
|
||||
workletCode,
|
||||
audioContext: getAudioContext(),
|
||||
});
|
||||
}
|
||||
return D.ready;
|
||||
}
|
||||
|
||||
export async function doughOutput(hap, targetTime, cps = 1) {
|
||||
const offset = D.context_offset?.[0];
|
||||
if (!offset) {
|
||||
return; // not ready
|
||||
}
|
||||
hap.ensureObjectValue();
|
||||
const event = {
|
||||
dough: 'play',
|
||||
...hap.value,
|
||||
time: targetTime - offset,
|
||||
duration: hap.duration / cps,
|
||||
};
|
||||
if (typeof event.note === 'string') {
|
||||
event.note = noteToMidi(event.note);
|
||||
}
|
||||
D.evaluate(event);
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* Uses dough as the audio engine. more info at https://dough.strudel.cc
|
||||
*
|
||||
* @name dough
|
||||
* @tags external_io
|
||||
* @memberof Pattern
|
||||
* @returns Pattern
|
||||
* @example
|
||||
* $: chord("<Dm9 Dm11 Dm7>").offset("<-1 0 1 0>").voicing()
|
||||
* .phaser(3).fm(1.4).fmh(1.01)
|
||||
* .dough()
|
||||
*/
|
||||
export const dough = register('dough', (pat) => {
|
||||
initDough();
|
||||
ensureMinimalOutput();
|
||||
return pat.onSchedule(doughOutput);
|
||||
});
|
||||
@@ -1,42 +0,0 @@
|
||||
{
|
||||
"name": "@strudel/dough",
|
||||
"version": "1.3.2",
|
||||
"description": "dough synth integration for strudel",
|
||||
"main": "dough.mjs",
|
||||
"type": "module",
|
||||
"publishConfig": {
|
||||
"main": "dist/index.mjs"
|
||||
},
|
||||
"scripts": {
|
||||
"build": "vite build",
|
||||
"prepublishOnly": "npm run build"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git+https://codeberg.org/uzu/strudel.git"
|
||||
},
|
||||
"keywords": [
|
||||
"tidalcycles",
|
||||
"strudel",
|
||||
"pattern",
|
||||
"livecoding",
|
||||
"algorave"
|
||||
],
|
||||
"author": "Felix Roos <flix91@gmail.com>",
|
||||
"license": "AGPL-3.0-or-later",
|
||||
"bugs": {
|
||||
"url": "https://codeberg.org/uzu/strudel/issues"
|
||||
},
|
||||
"homepage": "https://codeberg.org/uzu/strudel#readme",
|
||||
"dependencies": {
|
||||
"@strudel/core": "workspace:*",
|
||||
"@strudel/webaudio": "workspace:*",
|
||||
"dough-synth": "0.2.4"
|
||||
},
|
||||
"devDependencies": {
|
||||
"vite": "^6.0.11"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=18.0.0"
|
||||
}
|
||||
}
|
||||
+70
-74
@@ -13,7 +13,7 @@ import {
|
||||
getIsStarted,
|
||||
getPattern,
|
||||
getTime,
|
||||
getScheduleFunc,
|
||||
getTriggerFunc,
|
||||
isPattern,
|
||||
logger,
|
||||
ref,
|
||||
@@ -21,8 +21,8 @@ import {
|
||||
} from '@strudel/core';
|
||||
import { noteToMidi, getControlName } from '@strudel/core';
|
||||
import { Note } from 'webmidi';
|
||||
import { getAudioContext, getClockBridge } from '@strudel/webaudio';
|
||||
import { scheduleAtTime, ensureMinimalOutput } from '../superdough/helpers.mjs';
|
||||
import { getAudioContext } from '@strudel/webaudio';
|
||||
import { scheduleAtTime } from '../superdough/helpers.mjs';
|
||||
import { getMidiDeviceNamesString, getDevice } from './util.mjs';
|
||||
import { MidiInput } from './input.mjs';
|
||||
|
||||
@@ -171,23 +171,6 @@ function normalize(value = 0, min = 0, max = 1, exp = 1) {
|
||||
return Math.pow(normalized, exp);
|
||||
}
|
||||
|
||||
const isFirefox = navigator?.userAgent?.includes('Firefox');
|
||||
// call fn either directly with given time (non-firefox) or after scheduleAtTime with undefined (firefox)
|
||||
// the scheduleAtTime approach is still jittery, but the best we can be on firefox
|
||||
// firefox bug: https://bugzilla.mozilla.org/show_bug.cgi?id=2062997
|
||||
function timedSend(timeMs, fn) {
|
||||
if (isFirefox) {
|
||||
const audioTime = getClockBridge().getAudioContextTime(timeMs);
|
||||
if (!audioTime) {
|
||||
logger('[midi]: skip event, not ready');
|
||||
return;
|
||||
}
|
||||
scheduleAtTime(() => fn(undefined), audioTime);
|
||||
} else {
|
||||
fn(timeMs);
|
||||
}
|
||||
}
|
||||
|
||||
function mapCC(mapping, value) {
|
||||
return Object.keys(value)
|
||||
.filter((key) => !!mapping[getControlName(key)])
|
||||
@@ -199,7 +182,7 @@ function mapCC(mapping, value) {
|
||||
}
|
||||
|
||||
// sends a cc message to the given device on the given channel
|
||||
function sendCC(ccn, ccv, device, midichan, timeMs) {
|
||||
function sendCC(ccn, ccv, device, midichan, targetTime) {
|
||||
if (typeof ccv !== 'number' || ccv < 0 || ccv > 1) {
|
||||
throw new Error('expected ccv to be a number between 0 and 1');
|
||||
}
|
||||
@@ -207,19 +190,23 @@ function sendCC(ccn, ccv, device, midichan, timeMs) {
|
||||
throw new Error('expected ccn to be a number or a string');
|
||||
}
|
||||
const scaled = Math.round(ccv * 127);
|
||||
timedSend(timeMs, (timeMs) => device.sendControlChange(ccn, scaled, { channels: midichan, time: timeMs }));
|
||||
scheduleAtTime(() => {
|
||||
device.sendControlChange(ccn, scaled, midichan);
|
||||
}, targetTime);
|
||||
}
|
||||
|
||||
// sends a program change message to the given device on the given channel
|
||||
function sendProgramChange(progNum, device, midichan, timeMs) {
|
||||
function sendProgramChange(progNum, device, midichan, targetTime) {
|
||||
if (typeof progNum !== 'number' || progNum < 0 || progNum > 127) {
|
||||
throw new Error('expected progNum (program change) to be a number between 0 and 127');
|
||||
}
|
||||
timedSend(timeMs, (timeMs) => device.sendProgramChange(progNum, { channels: midichan, time: timeMs }));
|
||||
scheduleAtTime(() => {
|
||||
device.sendProgramChange(progNum, midichan);
|
||||
}, targetTime);
|
||||
}
|
||||
|
||||
// sends a sysex message to the given device on the given channel
|
||||
function sendSysex(sysexid, sysexdata, device, timeMs) {
|
||||
function sendSysex(sysexid, sysexdata, device, targetTime) {
|
||||
if (Array.isArray(sysexid)) {
|
||||
if (!sysexid.every((byte) => Number.isInteger(byte) && byte >= 0 && byte <= 255)) {
|
||||
throw new Error('all sysexid bytes must be integers between 0 and 255');
|
||||
@@ -234,11 +221,13 @@ function sendSysex(sysexid, sysexdata, device, timeMs) {
|
||||
if (!sysexdata.every((byte) => Number.isInteger(byte) && byte >= 0 && byte <= 255)) {
|
||||
throw new Error('all sysex bytes must be integers between 0 and 255');
|
||||
}
|
||||
timedSend(timeMs, (timeMs) => device.sendSysex(sysexid, sysexdata, { time: timeMs }));
|
||||
scheduleAtTime(() => {
|
||||
device.sendSysex(sysexid, sysexdata);
|
||||
}, targetTime);
|
||||
}
|
||||
|
||||
// sends a NRPN message to the given device on the given channel
|
||||
function sendNRPN(nrpnn, nrpv, device, midichan, timeMs) {
|
||||
function sendNRPN(nrpnn, nrpv, device, midichan, targetTime) {
|
||||
if (Array.isArray(nrpnn)) {
|
||||
if (!nrpnn.every((byte) => Number.isInteger(byte) && byte >= 0 && byte <= 255)) {
|
||||
throw new Error('all nrpnn bytes must be integers between 0 and 255');
|
||||
@@ -246,29 +235,34 @@ function sendNRPN(nrpnn, nrpv, device, midichan, timeMs) {
|
||||
} else if (!Number.isInteger(nrpv) || nrpv < 0 || nrpv > 255) {
|
||||
throw new Error('A:sysexid must be an number between 0 and 255 or an array of such integers');
|
||||
}
|
||||
|
||||
timedSend(timeMs, (timeMs) => device.sendNrpnValue(nrpnn, nrpv, { channels: midichan, time: timeMs }));
|
||||
scheduleAtTime(() => {
|
||||
device.sendNRPN(nrpnn, nrpv, midichan);
|
||||
}, targetTime);
|
||||
}
|
||||
|
||||
// sends a pitch bend message to the given device on the given channel
|
||||
function sendPitchBend(midibend, device, midichan, timeMs) {
|
||||
function sendPitchBend(midibend, device, midichan, targetTime) {
|
||||
if (typeof midibend !== 'number' || midibend < -1 || midibend > 1) {
|
||||
throw new Error('expected midibend to be a number between -1 and 1');
|
||||
}
|
||||
timedSend(timeMs, (timeMs) => device.sendPitchBend(midibend, { channels: midichan, time: timeMs }));
|
||||
scheduleAtTime(() => {
|
||||
device.sendPitchBend(midibend, midichan);
|
||||
}, targetTime);
|
||||
}
|
||||
|
||||
// sends a channel aftertouch message to the given device on the given channel
|
||||
function sendAftertouch(miditouch, device, midichan, timeMs) {
|
||||
function sendAftertouch(miditouch, device, midichan, targetTime) {
|
||||
if (typeof miditouch !== 'number' || miditouch < 0 || miditouch > 1) {
|
||||
throw new Error('expected miditouch to be a number between 0 and 1');
|
||||
}
|
||||
|
||||
timedSend(timeMs, (timeMs) => device.sendChannelAftertouch(miditouch, { channels: midichan, time: timeMs }));
|
||||
scheduleAtTime(() => {
|
||||
device.sendChannelAftertouch(miditouch, midichan);
|
||||
}, targetTime);
|
||||
}
|
||||
|
||||
// sends a note message to the given device on the given channel
|
||||
function sendNote(note, velocity, duration, device, midichan, timeMs) {
|
||||
function sendNote(note, velocity, duration, device, midichan, targetTime) {
|
||||
if (note == null || note === '') {
|
||||
throw new Error('note cannot be null or empty');
|
||||
}
|
||||
@@ -279,10 +273,11 @@ function sendNote(note, velocity, duration, device, midichan, timeMs) {
|
||||
throw new Error('duration must be a positive number');
|
||||
}
|
||||
const midiNumber = typeof note === 'number' ? note : noteToMidi(note);
|
||||
const midiNote = new Note(midiNumber, { attack: velocity });
|
||||
const midiNote = new Note(midiNumber, { attack: velocity, duration });
|
||||
|
||||
timedSend(timeMs, (timeMs) => device.sendNoteOn(midiNote, { channels: midichan, time: timeMs }));
|
||||
timedSend(timeMs + duration, (timeMs) => device.sendNoteOff(midiNote, { channels: midichan, time: timeMs }));
|
||||
scheduleAtTime(() => {
|
||||
device.playNote(midiNote, midichan);
|
||||
}, targetTime);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -292,6 +287,8 @@ function sendNote(note, velocity, duration, device, midichan, timeMs) {
|
||||
* @param {object} options Additional MIDI configuration options
|
||||
* @example
|
||||
* note("c4").midichan(1).midi('IAC Driver Bus 1')
|
||||
* @example
|
||||
* note("c4").midichan(1).midi('IAC Driver Bus 1', { controller: true, latency: 50 })
|
||||
*/
|
||||
|
||||
Pattern.prototype.midi = function (midiport, options = {}) {
|
||||
@@ -317,7 +314,7 @@ Pattern.prototype.midi = function (midiport, options = {}) {
|
||||
let midiConfig = {
|
||||
// Default configuration values
|
||||
isController: false, // Disable sending notes for midi controllers
|
||||
noteOffsetMs: isFirefox ? 10 : 1, // Default note-off offset to prevent glitching in ms. firefox needs more slack
|
||||
noteOffsetMs: 10, // Default note-off offset to prevent glitching in ms
|
||||
midichannel: 1, // Default MIDI channel
|
||||
velocity: 0.9, // Default velocity
|
||||
gain: 1, // Default gain
|
||||
@@ -340,19 +337,11 @@ Pattern.prototype.midi = function (midiport, options = {}) {
|
||||
logger(`Midi device disconnected! Available: ${getMidiDeviceNamesString(outputs)}`),
|
||||
});
|
||||
|
||||
ensureMinimalOutput();
|
||||
|
||||
return this.sortHapsByPart().onSchedule((hap, targetTime, cps) => {
|
||||
return this.onTrigger((hap, _currentTime, cps, targetTime) => {
|
||||
if (!WebMidi.enabled) {
|
||||
logger('Midi not enabled');
|
||||
return;
|
||||
}
|
||||
const timeMs = getClockBridge().getPerformanceTime(targetTime);
|
||||
if (!timeMs) {
|
||||
logger('[midi] clockbridge not ready');
|
||||
return;
|
||||
}
|
||||
|
||||
hap.ensureObjectValue();
|
||||
|
||||
// midi event values from hap with configurable defaults
|
||||
@@ -390,7 +379,7 @@ Pattern.prototype.midi = function (midiport, options = {}) {
|
||||
// if midimap is set, send a cc messages from defined controls
|
||||
if (midicontrolMap.has(midimap)) {
|
||||
const ccs = mapCC(midicontrolMap.get(midimap), hap.value);
|
||||
ccs.forEach(({ ccn, ccv }) => sendCC(ccn, ccv, device, midichan, timeMs));
|
||||
ccs.forEach(({ ccn, ccv }) => sendCC(ccn, ccv, device, midichan, targetTime));
|
||||
} else if (midimap !== 'default') {
|
||||
// Add warning when a non-existent midimap is specified
|
||||
logger(`[midi] midimap "${midimap}" not found! Available maps: ${[...midicontrolMap.keys()].join(', ')}`);
|
||||
@@ -398,20 +387,16 @@ Pattern.prototype.midi = function (midiport, options = {}) {
|
||||
|
||||
// Handle note
|
||||
if (note !== undefined && !midiConfig.isController) {
|
||||
// note off time is calculated early, together with note on time
|
||||
// when the note off is due, the clock might have drifted, and the next note on message might happen before the note off
|
||||
// this would lead to the next note being cut off
|
||||
// this is why we make notes shorter by noteOffsetMs, so note offs happen earlier than the note ons after
|
||||
const hapDuration = (hap.duration.valueOf() / cps) * 1000;
|
||||
const offset = Math.min(midiConfig.noteOffsetMs, hapDuration / 2);
|
||||
const duration = hapDuration - offset;
|
||||
// note off messages will often a few ms arrive late,
|
||||
// try to prevent glitching by subtracting noteOffsetMs from the duration length
|
||||
const duration = (hap.duration.valueOf() / cps) * 1000 - midiConfig.noteOffsetMs;
|
||||
|
||||
sendNote(note, velocity, duration, device, midichan, timeMs);
|
||||
sendNote(note, velocity, duration, device, midichan, targetTime);
|
||||
}
|
||||
|
||||
// Handle program change
|
||||
if (progNum !== undefined) {
|
||||
sendProgramChange(progNum, device, midichan, timeMs);
|
||||
sendProgramChange(progNum, device, midichan, targetTime);
|
||||
}
|
||||
|
||||
// Handle sysex
|
||||
@@ -421,53 +406,63 @@ Pattern.prototype.midi = function (midiport, options = {}) {
|
||||
// if sysexid is an array the first byte is 0x00
|
||||
|
||||
if (sysexid !== undefined && sysexdata !== undefined) {
|
||||
sendSysex(sysexid, sysexdata, device, timeMs);
|
||||
sendSysex(sysexid, sysexdata, device, targetTime);
|
||||
}
|
||||
|
||||
// Handle control change
|
||||
if (ccv !== undefined && ccn !== undefined) {
|
||||
sendCC(ccn, ccv, device, midichan, timeMs);
|
||||
sendCC(ccn, ccv, device, midichan, targetTime);
|
||||
}
|
||||
|
||||
// Handle NRPN non-registered parameter number
|
||||
if (nrpnn !== undefined && nrpv !== undefined) {
|
||||
sendNRPN(nrpnn, nrpv, device, midichan, timeMs);
|
||||
sendNRPN(nrpnn, nrpv, device, midichan, targetTime);
|
||||
}
|
||||
|
||||
// Handle midibend
|
||||
if (midibend !== undefined) {
|
||||
sendPitchBend(midibend, device, midichan, timeMs);
|
||||
sendPitchBend(midibend, device, midichan, targetTime);
|
||||
}
|
||||
|
||||
// Handle miditouch
|
||||
if (miditouch !== undefined) {
|
||||
sendAftertouch(miditouch, device, midichan, timeMs);
|
||||
sendAftertouch(miditouch, device, midichan, targetTime);
|
||||
}
|
||||
|
||||
// Handle midicmd
|
||||
if (hap.whole.begin + 0 === 0) {
|
||||
// we need to start here because we have the timing info
|
||||
timedSend(timeMs, (timeMs) => device.sendStart({ time: timeMs }));
|
||||
scheduleAtTime(() => {
|
||||
device.sendStart();
|
||||
}, targetTime);
|
||||
}
|
||||
if (['clock', 'midiClock'].includes(midicmd)) {
|
||||
timedSend(timeMs, (timeMs) => device.sendClock({ time: timeMs }));
|
||||
scheduleAtTime(() => {
|
||||
device.sendClock();
|
||||
}, targetTime);
|
||||
} else if (['start'].includes(midicmd)) {
|
||||
timedSend(timeMs, (timeMs) => device.sendStart({ time: timeMs }));
|
||||
scheduleAtTime(() => {
|
||||
device.sendStart();
|
||||
}, targetTime);
|
||||
} else if (['stop'].includes(midicmd)) {
|
||||
timedSend(timeMs, (timeMs) => device.sendStop({ time: timeMs }));
|
||||
scheduleAtTime(() => {
|
||||
device.sendStop();
|
||||
}, targetTime);
|
||||
} else if (['continue'].includes(midicmd)) {
|
||||
timedSend(timeMs, (timeMs) => device.sendContinue({ time: timeMs }));
|
||||
scheduleAtTime(() => {
|
||||
device.sendContinue();
|
||||
}, targetTime);
|
||||
} else if (Array.isArray(midicmd)) {
|
||||
if (midicmd[0] === 'progNum') {
|
||||
sendProgramChange(midicmd[1], device, midichan, timeMs);
|
||||
sendProgramChange(midicmd[1], device, midichan, targetTime);
|
||||
} else if (midicmd[0] === 'cc') {
|
||||
if (midicmd.length === 2) {
|
||||
sendCC(midicmd[0], midicmd[1] / 127, device, midichan, timeMs);
|
||||
sendCC(midicmd[0], midicmd[1] / 127, device, midichan, targetTime);
|
||||
}
|
||||
} else if (midicmd[0] === 'sysex') {
|
||||
if (midicmd.length === 3) {
|
||||
const [_, id, data] = midicmd;
|
||||
sendSysex(id, data, device, timeMs);
|
||||
sendSysex(id, data, device, targetTime);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -570,8 +565,8 @@ const kListeners = {};
|
||||
|
||||
function _triggerKeyboard(input, cps, now, latencyCycles) {
|
||||
const pattern = getPattern();
|
||||
const schedule = getScheduleFunc();
|
||||
if (!pattern || !schedule) {
|
||||
const trigger = getTriggerFunc();
|
||||
if (!pattern || !trigger) {
|
||||
return false;
|
||||
}
|
||||
const t = now + latencyCycles;
|
||||
@@ -588,7 +583,8 @@ function _triggerKeyboard(input, cps, now, latencyCycles) {
|
||||
return;
|
||||
}
|
||||
const t = ctxNow + (hap.whole.begin - now) / cps;
|
||||
schedule(hap, t, cps);
|
||||
const duration = hap.duration / cps;
|
||||
trigger(hap, t - ctxNow, duration, cps, t);
|
||||
});
|
||||
|
||||
return true;
|
||||
@@ -623,7 +619,7 @@ export async function midikeys(input) {
|
||||
noteoff ||= noteon && velocity === 0; // handle devices which may use velocity = 0 to signal noteoff
|
||||
const key = `${input}_${note}`;
|
||||
const cps = getCps() ?? 0.5;
|
||||
const triggerAvailable = !!(getPattern() && getScheduleFunc());
|
||||
const triggerAvailable = !!(getPattern() && getTriggerFunc());
|
||||
const latencySeconds = triggerAvailable ? 0.01 : 0.06; // avoid missing notes due to cyclist / trigger latency
|
||||
const now = getTime();
|
||||
const t = now + latencySeconds * cps;
|
||||
|
||||
@@ -84,22 +84,6 @@ describe('mini', () => {
|
||||
it('supports patterning euclidean rhythms', () => {
|
||||
expect(minS('[a(<3 5>, <8 16>)]*2')).toEqual(minS('a(3,8) a(5,16)'));
|
||||
});
|
||||
it('supports inverted euclidean rhythms', () => {
|
||||
expect(minS('a(-3, 8)')).toEqual(['a: 1/8 - 1/4', 'a: 1/4 - 3/8', 'a: 1/2 - 5/8', 'a: 5/8 - 3/4', 'a: 7/8 - 1']);
|
||||
});
|
||||
it('supports euclidean legato rhythms', () => {
|
||||
expect(minS('a(3, -8)')).toEqual(['a: 0 - 3/8', 'a: 3/8 - 3/4', 'a: 3/4 - 1']);
|
||||
});
|
||||
it('supports inverted euclidean legato rhythms', () => {
|
||||
expect(minS('a(-3, -8)')).toEqual([
|
||||
'a: -1/8 - 1/8',
|
||||
'a: 1/8 - 1/4',
|
||||
'a: 1/4 - 1/2',
|
||||
'a: 1/2 - 5/8',
|
||||
'a: 5/8 - 7/8',
|
||||
'a: 7/8 - 9/8',
|
||||
]);
|
||||
});
|
||||
it("reproduces Toussaint's example euclidean algorithms", () => {
|
||||
const checkEuclid = function (spec, target) {
|
||||
expect(minS(`x(${spec[0]},${spec[1]})`)).toEqual(minS(target));
|
||||
@@ -134,40 +118,6 @@ describe('mini', () => {
|
||||
checkEuclid([11, 24], 'x ~ ~ x ~ x ~ x ~ x ~ x ~ ~ x ~ x ~ x ~ x ~ x ~');
|
||||
checkEuclid([13, 24], 'x ~ x x ~ x ~ x ~ x ~ x ~ x x ~ x ~ x ~ x ~ x ~');
|
||||
});
|
||||
it("reproduces Toussaint's example euclidean legato algorithms", () => {
|
||||
const checkEuclid = function (spec, target) {
|
||||
expect(minS(`x(${spec[0]},${spec[1]})`)).toEqual(minS(target));
|
||||
};
|
||||
checkEuclid([1, -2], 'x _');
|
||||
checkEuclid([1, -3], 'x _ _');
|
||||
checkEuclid([1, -4], 'x _ _ _');
|
||||
checkEuclid([4, -12], 'x _ _ x _ _ x _ _ x _ _');
|
||||
checkEuclid([2, -5], 'x _ x _ _');
|
||||
// checkEuclid([3, 4], "x _ x x"); // Toussaint is wrong..
|
||||
checkEuclid([3, -4], 'x x x _'); // correction
|
||||
checkEuclid([3, -5], 'x _ x _ x');
|
||||
checkEuclid([3, -7], 'x _ x _ x _ _');
|
||||
checkEuclid([3, -8], 'x _ _ x _ _ x _');
|
||||
checkEuclid([4, -7], 'x _ x _ x _ x');
|
||||
checkEuclid([4, -9], 'x _ x _ x _ x _ _');
|
||||
checkEuclid([4, -11], 'x _ _ x _ _ x _ _ x _');
|
||||
// checkEuclid([5, 6], "x _ x x x x"); // Toussaint is wrong..
|
||||
checkEuclid([5, -6], 'x x x x x _'); // correction
|
||||
checkEuclid([5, -7], 'x _ x x _ x x');
|
||||
checkEuclid([5, -8], 'x _ x x _ x x _');
|
||||
checkEuclid([5, -9], 'x _ x _ x _ x _ x');
|
||||
checkEuclid([5, -11], 'x _ x _ x _ x _ x _ _');
|
||||
checkEuclid([5, -12], 'x _ _ x _ x _ _ x _ x _');
|
||||
// checkEuclid([5, 16], "x _ _ x _ _ x _ _ x _ _ x _ _ _ _"); // Toussaint is wrong..
|
||||
checkEuclid([5, -16], 'x _ _ x _ _ x _ _ x _ _ x _ _ _'); // correction
|
||||
// checkEuclid([7, 8], "x _ x x x x x x"); // Toussaint is wrong..
|
||||
checkEuclid([7, -8], 'x x x x x x x _'); // Correction
|
||||
checkEuclid([7, -12], 'x _ x x _ x _ x x _ x _');
|
||||
checkEuclid([7, -16], 'x _ _ x _ x _ x _ _ x _ x _ x _');
|
||||
checkEuclid([9, -16], 'x _ x x _ x _ x _ x x _ x _ x _');
|
||||
checkEuclid([11, -24], 'x _ _ x _ x _ x _ x _ x _ _ x _ x _ x _ x _ x _');
|
||||
checkEuclid([13, -24], 'x _ x x _ x _ x _ x _ x _ x x _ x _ x _ x _ x _');
|
||||
});
|
||||
it('supports the - alias for ~', () => {
|
||||
expect(minS('a - b [- c]')).toEqual(minS('a ~ b [~ c]'));
|
||||
});
|
||||
|
||||
+55
-13
@@ -5,6 +5,12 @@ This program is free software: you can redistribute it and/or modify it under th
|
||||
*/
|
||||
|
||||
// evolved from https://garten.salat.dev/lisp/parser.html
|
||||
|
||||
let recurse = 0
|
||||
function lrec(...args) {
|
||||
recurse += 1
|
||||
console.info(recurse, ...args)
|
||||
}
|
||||
export class MondoParser {
|
||||
// these are the tokens we expect
|
||||
token_types = {
|
||||
@@ -24,10 +30,17 @@ export class MondoParser {
|
||||
op: /^[*/:!@%?+\-&]|^\.{2}/, // * / : ! @ % ? ..
|
||||
// dollar: /^\$/,
|
||||
pipe: /^#/,
|
||||
stack: /^[,$]/,
|
||||
// Matches _$ or _$BASS
|
||||
mute_stack: /^_\$([a-zA-Z0-9_]+)?/,
|
||||
// Matches S$ or S$VOCALS
|
||||
solo_stack: /^S\$([a-zA-Z0-9_]+)?/,
|
||||
// stack: /^[,$]/,
|
||||
stack: /^,|^\$([a-zA-Z0-9_]+)?/,
|
||||
or: /^[|]/,
|
||||
plain: /^[a-zA-Z0-9-~_^#]+/,
|
||||
|
||||
};
|
||||
solo_enabled = false;
|
||||
op_precedence = [['*', '/', ':', '!', '@', '%', '?', '+', '-', '..'], ['&']];
|
||||
// matches next token
|
||||
next_token(code, offset = 0) {
|
||||
@@ -62,6 +75,7 @@ export class MondoParser {
|
||||
offset += token.value.length;
|
||||
tokens.push(token);
|
||||
}
|
||||
lrec("TOKENS", tokens[0], tokens[1])
|
||||
return tokens;
|
||||
}
|
||||
// take code, return abstract syntax tree
|
||||
@@ -73,19 +87,22 @@ export class MondoParser {
|
||||
while (this.tokens.length) {
|
||||
expressions.push(this.parse_expr());
|
||||
}
|
||||
let parsed = expressions[0]
|
||||
if (expressions.length === 0) {
|
||||
// empty case
|
||||
return { type: 'list', children: [] };
|
||||
}
|
||||
parsed = { type: 'list', children: [] };
|
||||
} else if (expressions.length > 1 || expressions[0].type !== 'list')
|
||||
// do we have multiple top level expressions or a single non list?
|
||||
if (expressions.length > 1 || expressions[0].type !== 'list') {
|
||||
return {
|
||||
{
|
||||
parsed = {
|
||||
type: 'list',
|
||||
children: this.desugar(expressions),
|
||||
};
|
||||
}
|
||||
|
||||
lrec("PARSED", parsed)
|
||||
// we have a single list
|
||||
return expressions[0];
|
||||
return parsed;
|
||||
}
|
||||
// parses any valid expression
|
||||
parse_expr() {
|
||||
@@ -120,8 +137,11 @@ export class MondoParser {
|
||||
children = children.slice(splitIndex + 1);
|
||||
}
|
||||
chunks.push(children);
|
||||
lrec("chunks", chunks)
|
||||
return chunks;
|
||||
}
|
||||
|
||||
|
||||
desugar_split(children, split_type, next) {
|
||||
const chunks = this.split_children(children, split_type);
|
||||
if (chunks.length === 1) {
|
||||
@@ -253,12 +273,15 @@ export class MondoParser {
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
desugar(children, type) {
|
||||
// if type is given, the first element is expected to contain it as plain value
|
||||
// e.g. with (square a b, c), we want to split (a b, c) and ignore "square"
|
||||
children = type ? children.slice(1) : children;
|
||||
children = this.desugar_split(children, 'stack', (children) =>
|
||||
this.desugar_split(children, 'or', (children) => {
|
||||
|
||||
const desugar_split_children = (children) => {
|
||||
return this.desugar_split(children, 'or', (children) => {
|
||||
console.info("TYPE", type)
|
||||
// chunks of multiple args
|
||||
if (type) {
|
||||
// the type we've removed before splitting needs to be added back
|
||||
@@ -269,14 +292,34 @@ export class MondoParser {
|
||||
children = this.desugar_ops(children, ops);
|
||||
});
|
||||
children = this.desugar_pipes(children);
|
||||
lrec("STACK CHILDREN", children)
|
||||
return children;
|
||||
}),
|
||||
);
|
||||
})
|
||||
|
||||
}
|
||||
|
||||
console.info("PRE_CHILDREN", children)
|
||||
// children = this.desugar_split(children, 'mute_stack', (children) => {
|
||||
// const x = desugar_split_children(children)
|
||||
// // lrec({x})
|
||||
// return x
|
||||
// })
|
||||
|
||||
lrec({ children })
|
||||
|
||||
|
||||
children = this.desugar_split(children, 'stack', (children) => {
|
||||
return desugar_split_children(children)
|
||||
})
|
||||
|
||||
|
||||
lrec("CHILDREN", children)
|
||||
return children;
|
||||
}
|
||||
parse_list() {
|
||||
let node = this.parse_pair('open_list', 'close_list');
|
||||
node.children = this.desugar(node.children);
|
||||
lrec("node", node)
|
||||
return node;
|
||||
}
|
||||
parse_angle() {
|
||||
@@ -325,9 +368,8 @@ export function printAst(ast, compact = false, lvl = 0) {
|
||||
const br = compact ? '' : '\n';
|
||||
const spaces = compact ? '' : Array(lvl).fill(' ').join('');
|
||||
if (ast.type === 'list') {
|
||||
return `${lvl ? br : ''}${spaces}(${ast.children.map((child) => printAst(child, compact, lvl + 1)).join(' ')}${
|
||||
ast.children.find((child) => child.type === 'list') ? `${br}${spaces})` : ')'
|
||||
}`;
|
||||
return `${lvl ? br : ''}${spaces}(${ast.children.map((child) => printAst(child, compact, lvl + 1)).join(' ')}${ast.children.find((child) => child.type === 'list') ? `${br}${spaces})` : ')'
|
||||
}`;
|
||||
}
|
||||
return `${ast.value}`;
|
||||
}
|
||||
|
||||
@@ -46,12 +46,14 @@ lib[':'] = tail;
|
||||
lib['..'] = range;
|
||||
lib['def'] = () => silence;
|
||||
lib['or'] = (...children) => chooseIn(...children); // always has structure but is cyclewise.. e.g. "s oh*8.dec[.04 | .5]"
|
||||
//lib['or'] = (...children) => chooseOut(...children); // "s oh*8.dec[.04 | .5]" is better but "dec[.04 | .5].s oh*8" has no struct
|
||||
|
||||
function evaluator(node, scope) {
|
||||
const { type } = node;
|
||||
// node is list
|
||||
if (type === 'list') {
|
||||
const { children } = node;
|
||||
const { type,children } = node;
|
||||
// node is list]
|
||||
if (type === 'list' && children.length) {
|
||||
// const { children } = node;
|
||||
|
||||
const [name, ...args] = children;
|
||||
// some functions wont be reified to make sure they work (e.g. see extend below)
|
||||
if (typeof name === 'function') {
|
||||
@@ -64,6 +66,7 @@ function evaluator(node, scope) {
|
||||
const first = name.firstCycle(true)[0];
|
||||
const type = typeof first?.value;
|
||||
if (type !== 'function') {
|
||||
console.error("first", first)
|
||||
throw new Error(`[mondough] expected function, got "${first?.value}"`);
|
||||
}
|
||||
return name
|
||||
@@ -75,12 +78,16 @@ function evaluator(node, scope) {
|
||||
})
|
||||
.innerJoin();
|
||||
}
|
||||
|
||||
console.info("NODE", node)
|
||||
// node is leaf
|
||||
let { value } = node;
|
||||
if (type === 'plain' && scope[value]) {
|
||||
return reify(scope[value]); // -> local scope has no location
|
||||
}
|
||||
const variable = lib[value] ?? strudelScope[value];
|
||||
|
||||
console.info("VARIABLE", variable)
|
||||
// problem: collisions when we want a string that happens to also be a variable name
|
||||
// example: "s sine" -> sine is also a variable
|
||||
let pat;
|
||||
@@ -106,6 +113,7 @@ export function mondo(code, offset = 0) {
|
||||
code = code.join('');
|
||||
}
|
||||
const pat = runner.run(code, undefined, offset);
|
||||
console.info("MONDO_PAT", pat)
|
||||
return pat.markcss('color: var(--caret,--foreground);text-decoration:underline');
|
||||
}
|
||||
|
||||
|
||||
+32
-29
@@ -4,7 +4,7 @@ Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
import { Pattern, getClockTime, createParams } from '@strudel/core';
|
||||
import { Pattern, isPattern, createParams } from '@strudel/core';
|
||||
import Paho from 'paho-mqtt';
|
||||
|
||||
const connections = {};
|
||||
@@ -80,39 +80,42 @@ Pattern.prototype.mqtt = function (
|
||||
}
|
||||
cx.connect(props);
|
||||
}
|
||||
return this.onSchedule((hap, targetTime, cps) => {
|
||||
let msg_topic = topic;
|
||||
if (!cx || !cx.isConnected()) {
|
||||
return;
|
||||
}
|
||||
let message = '';
|
||||
if (typeof hap.value === 'object') {
|
||||
let value = hap.value;
|
||||
return this.withHap((hap) => {
|
||||
const onTrigger = (hap, currentTime, cps, targetTime) => {
|
||||
let msg_topic = topic;
|
||||
if (!cx || !cx.isConnected()) {
|
||||
return;
|
||||
}
|
||||
let message = '';
|
||||
if (typeof hap.value === 'object') {
|
||||
let value = hap.value;
|
||||
|
||||
// Try to take topic from pattern if it's not set
|
||||
if (typeof msg_topic === 'undefined' && 'topic' in value) {
|
||||
msg_topic = value.topic;
|
||||
if (Array.isArray(msg_topic)) {
|
||||
msg_topic = msg_topic.join('/');
|
||||
// Try to take topic from pattern if it's not set
|
||||
if (typeof msg_topic === 'undefined' && 'topic' in value) {
|
||||
msg_topic = value.topic;
|
||||
if (Array.isArray(msg_topic)) {
|
||||
msg_topic = msg_topic.join('/');
|
||||
}
|
||||
msg_topic = '/' + msg_topic;
|
||||
}
|
||||
msg_topic = '/' + msg_topic;
|
||||
if (add_meta) {
|
||||
const duration = hap.duration.div(cps);
|
||||
value = { ...value, duration: duration.valueOf(), cps: cps };
|
||||
}
|
||||
message = JSON.stringify(value);
|
||||
} else {
|
||||
message = hap.value;
|
||||
}
|
||||
if (add_meta) {
|
||||
const duration = hap.duration.div(cps);
|
||||
value = { ...value, duration: duration.valueOf(), cps: cps };
|
||||
}
|
||||
message = JSON.stringify(value);
|
||||
} else {
|
||||
message = hap.value;
|
||||
}
|
||||
message = new Paho.Message(message);
|
||||
message.destinationName = msg_topic;
|
||||
message = new Paho.Message(message);
|
||||
message.destinationName = msg_topic;
|
||||
|
||||
const offset = (targetTime - getClockTime() + latency) * 1000;
|
||||
const offset = (targetTime - currentTime + latency) * 1000;
|
||||
|
||||
window.setTimeout(function () {
|
||||
cx.send(message);
|
||||
}, offset);
|
||||
window.setTimeout(function () {
|
||||
cx.send(message);
|
||||
}, offset);
|
||||
};
|
||||
return hap.setContext({ ...hap.context, onTrigger, dominantTrigger: true });
|
||||
});
|
||||
};
|
||||
|
||||
|
||||
+7
-15
@@ -4,8 +4,7 @@ Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
import { logger, parseNumeral, register, isNote, noteToMidi } from '@strudel/core';
|
||||
import { ensureMinimalOutput, getClockBridge } from '@strudel/webaudio';
|
||||
import { logger, parseNumeral, register, isNote, noteToMidi, ClockCollator } from '@strudel/core';
|
||||
|
||||
let connection; // Promise<OSC>
|
||||
function connect() {
|
||||
@@ -46,6 +45,7 @@ export function parseControlsFromHap(hap, cps) {
|
||||
controls.midinote = parseNumeral(controls.note);
|
||||
}
|
||||
}
|
||||
controls.bank && (controls.s = controls.bank + controls.s);
|
||||
controls.roomsize && (controls.size = parseNumeral(controls.roomsize));
|
||||
// speed adjustment for CPS is handled on the DSP side in superdirt and pattern side in Strudel,
|
||||
// so we need to undo the adjustment before sending the message to superdirt.
|
||||
@@ -55,18 +55,13 @@ export function parseControlsFromHap(hap, cps) {
|
||||
return controls;
|
||||
}
|
||||
|
||||
export async function oscOutput(hap, targetTime, cps = 1) {
|
||||
const collator = new ClockCollator({});
|
||||
|
||||
export async function oscTrigger(hap, currentTime, cps = 1, targetTime) {
|
||||
const ws = await connect();
|
||||
|
||||
const timeMs = getClockBridge().getPerformanceTime(targetTime);
|
||||
if (!timeMs) {
|
||||
logger('[osc] clockbridge not ready');
|
||||
return;
|
||||
}
|
||||
const ts = performance.timeOrigin + timeMs;
|
||||
|
||||
const controls = parseControlsFromHap(hap, cps);
|
||||
const keyvals = Object.entries(controls).flat();
|
||||
const ts = collator.calculateTimestamp(currentTime, targetTime) * 1000;
|
||||
const msg = { address: '/dirt/play', args: keyvals, timestamp: ts };
|
||||
|
||||
if ('oschost' in hap.value) {
|
||||
@@ -88,7 +83,4 @@ export async function oscOutput(hap, targetTime, cps = 1) {
|
||||
* @memberof Pattern
|
||||
* @returns Pattern
|
||||
*/
|
||||
export const osc = register('osc', (pat) => {
|
||||
ensureMinimalOutput();
|
||||
return pat.onSchedule(oscOutput);
|
||||
});
|
||||
export const osc = register('osc', (pat) => pat.onTrigger(oscTrigger));
|
||||
|
||||
@@ -38,7 +38,6 @@
|
||||
"homepage": "https://codeberg.org/uzu/strudel#readme",
|
||||
"dependencies": {
|
||||
"@strudel/core": "workspace:*",
|
||||
"@strudel/webaudio": "workspace:*",
|
||||
"osc": "^2.4.5",
|
||||
"ws": "^8.18.3"
|
||||
},
|
||||
|
||||
@@ -1,7 +1,10 @@
|
||||
/* import { tauriOscOutput } from '../desktopbridge/oscbridge.mjs';
|
||||
/* import { oscTriggerTauri } from '../desktopbridge/oscbridge.mjs';
|
||||
import { isTauri } from '../desktopbridge/utils.mjs'; */
|
||||
import { oscOutput } from './osc.mjs';
|
||||
import { oscTrigger } from './osc.mjs';
|
||||
|
||||
const output = /* isTauri() ? tauriOscOutput : */ oscOutput;
|
||||
const trigger = /* isTauri() ? oscTriggerTauri : */ oscTrigger;
|
||||
|
||||
export const superdirtOutput = (hap, targetTime, cps) => output(hap, targetTime, cps);
|
||||
export const superdirtOutput = (hap, deadline, hapDuration, cps, targetTime) => {
|
||||
const currentTime = performance.now() / 1000;
|
||||
return trigger(hap, currentTime, cps, targetTime);
|
||||
};
|
||||
|
||||
@@ -37,7 +37,7 @@ if (typeof HTMLElement !== 'undefined') {
|
||||
const drawContext = getDrawContext();
|
||||
const drawTime = [-2, 2];
|
||||
this.editor = new StrudelMirror({
|
||||
onSchedule: webaudioOutput,
|
||||
defaultOutput: webaudioOutput,
|
||||
getTime: () => getAudioContext().currentTime,
|
||||
transpiler,
|
||||
root: container,
|
||||
|
||||
@@ -98,7 +98,6 @@ if (args.includes('--json')) {
|
||||
}
|
||||
writeFileSync(outFile, json, 'utf8');
|
||||
console.log(`Wrote json to ${outFile}`);
|
||||
process.exit(0);
|
||||
}
|
||||
|
||||
console.log(
|
||||
|
||||
+43
-40
@@ -4,7 +4,7 @@ Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
import { Pattern, getClockTime } from '@strudel/core';
|
||||
import { Pattern, isPattern } from '@strudel/core';
|
||||
|
||||
var writeMessagers = {};
|
||||
var choosing = false;
|
||||
@@ -64,50 +64,53 @@ function crc16(data) {
|
||||
}
|
||||
|
||||
Pattern.prototype.serial = function (br = 115200, sendcrc = false, singlecharids = false, name = 'default') {
|
||||
if (!(name in writeMessagers)) {
|
||||
getWriter(name, br);
|
||||
}
|
||||
return this.onSchedule((hap, targetTime) => {
|
||||
var message = '';
|
||||
var chk = 0;
|
||||
if (typeof hap.value === 'object') {
|
||||
if ('action' in hap.value) {
|
||||
var action = hap.value['action'];
|
||||
if (singlecharids) {
|
||||
action = action.charAt(0);
|
||||
}
|
||||
message += action + '(';
|
||||
var first = true;
|
||||
for (var [key, val] of Object.entries(hap.value)) {
|
||||
if (key === 'action') {
|
||||
continue;
|
||||
}
|
||||
if (first) {
|
||||
first = false;
|
||||
} else {
|
||||
message += ',';
|
||||
}
|
||||
return this.withHap((hap) => {
|
||||
if (!(name in writeMessagers)) {
|
||||
getWriter(name, br);
|
||||
}
|
||||
const onTrigger = (hap, currentTime, _cps, targetTime) => {
|
||||
var message = '';
|
||||
var chk = 0;
|
||||
if (typeof hap.value === 'object') {
|
||||
if ('action' in hap.value) {
|
||||
var action = hap.value['action'];
|
||||
if (singlecharids) {
|
||||
key = key.charAt(0);
|
||||
action = action.charAt(0);
|
||||
}
|
||||
message += action + '(';
|
||||
var first = true;
|
||||
for (var [key, val] of Object.entries(hap.value)) {
|
||||
if (key === 'action') {
|
||||
continue;
|
||||
}
|
||||
if (first) {
|
||||
first = false;
|
||||
} else {
|
||||
message += ',';
|
||||
}
|
||||
if (singlecharids) {
|
||||
key = key.charAt(0);
|
||||
}
|
||||
message += key + ':' + val;
|
||||
}
|
||||
message += ')';
|
||||
if (sendcrc) {
|
||||
chk = crc16(message);
|
||||
}
|
||||
} else {
|
||||
for (const [key, val] of Object.entries(hap.value)) {
|
||||
message += `${key}:${val}`;
|
||||
}
|
||||
message += key + ':' + val;
|
||||
}
|
||||
message += ')';
|
||||
if (sendcrc) {
|
||||
chk = crc16(message);
|
||||
}
|
||||
} else {
|
||||
for (const [key, val] of Object.entries(hap.value)) {
|
||||
message += `${key}:${val}`;
|
||||
}
|
||||
message = hap.value;
|
||||
}
|
||||
} else {
|
||||
message = hap.value;
|
||||
}
|
||||
const offset = (targetTime - getClockTime() + latency) * 1000;
|
||||
const offset = (targetTime - currentTime + latency) * 1000;
|
||||
|
||||
window.setTimeout(function () {
|
||||
writeMessagers[name](message, chk);
|
||||
}, offset);
|
||||
window.setTimeout(function () {
|
||||
writeMessagers[name](message, chk);
|
||||
}, offset);
|
||||
};
|
||||
return hap.setContext({ ...hap.context, onTrigger, dominantTrigger: true });
|
||||
});
|
||||
};
|
||||
|
||||
@@ -28,7 +28,7 @@ async function loadFont(name) {
|
||||
const url = `${soundfontUrl}/${name}.js`;
|
||||
const preset = await fetch(url).then((res) => res.text());
|
||||
let [_, data] = preset.split('={');
|
||||
return new Function('return {' + data)().zones;
|
||||
return eval('{' + data);
|
||||
};
|
||||
loadCache[name] = load();
|
||||
return loadCache[name];
|
||||
|
||||
@@ -479,7 +479,7 @@ export default {
|
||||
gm_electric_bass_finger: [
|
||||
// Electric Bass (finger): Bass
|
||||
'0330_JCLive_sf2_file',
|
||||
'0330_FluidR3_GM_sf2_file',
|
||||
'0330_FluidR3_GM_sf2_fible',
|
||||
'0330_Aspirin_sf2_file',
|
||||
//0330_Chaos_sf2_file // same as last
|
||||
'0330_GeneralUserGS_sf2_file',
|
||||
@@ -527,7 +527,7 @@ export default {
|
||||
'0370_Aspirin_sf2_file',
|
||||
// 0370_Chaos_sf2_file // same as last
|
||||
'0370_FluidR3_GM_sf2_file',
|
||||
'0370_GeneralUserGS_sf2_file',
|
||||
'0370_GeneralUserGS_sf2_fil e',
|
||||
'0370_JCLive_sf2_file',
|
||||
//0370_SBLive_sf2
|
||||
//0370_SoundBlasterOld_sf2
|
||||
@@ -1782,5 +1782,6 @@ export default {
|
||||
'1272_GeneralUserGS_sf2_file',
|
||||
'1273_GeneralUserGS_sf2_file',
|
||||
'1274_GeneralUserGS_sf2_file',
|
||||
'',
|
||||
],
|
||||
};
|
||||
|
||||
@@ -3,7 +3,7 @@ import { getAudioContext, registerSound } from '@strudel/webaudio';
|
||||
import { loadSoundfont as _loadSoundfont, startPresetNote } from 'sfumato';
|
||||
|
||||
Pattern.prototype.soundfont = function (sf, n = 0) {
|
||||
return this.onSchedule((h, targetTime) => {
|
||||
return this.onTrigger((h, ct, cps, targetTime) => {
|
||||
const ctx = getAudioContext();
|
||||
const note = getPlayableNoteValue(h);
|
||||
const preset = sf.presets[n % sf.presets.length];
|
||||
|
||||
@@ -7,24 +7,15 @@ Copyright (C) 2025 Strudel contributors - see <https://codeberg.org/uzu/strudel/
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
import { clearNodePool } from './nodePools.mjs';
|
||||
import { ClockBridge } from './clockbridge.mjs';
|
||||
|
||||
let audioContext, clockBridge;
|
||||
let audioContext;
|
||||
|
||||
export const setDefaultAudioContext = () => {
|
||||
return setAudioContext(new AudioContext());
|
||||
audioContext = new AudioContext();
|
||||
return audioContext;
|
||||
};
|
||||
|
||||
export const setAudioContext = (context) => {
|
||||
// Existing nodes in the node pool contain references to the previous AudioContext,
|
||||
// so all the nodes in the pool must be cleared when we set a new AudioContext.
|
||||
clearNodePool();
|
||||
if (audioContext && audioContext.state !== 'closed') {
|
||||
audioContext.close();
|
||||
}
|
||||
audioContext = context;
|
||||
clockBridge = new ClockBridge(audioContext);
|
||||
return audioContext;
|
||||
};
|
||||
|
||||
@@ -36,13 +27,6 @@ export const getAudioContext = () => {
|
||||
return audioContext;
|
||||
};
|
||||
|
||||
export function getClockBridge() {
|
||||
if (!clockBridge) {
|
||||
getAudioContext(); // creates clockBridge
|
||||
}
|
||||
return clockBridge;
|
||||
}
|
||||
|
||||
export function getAudioContextCurrentTime() {
|
||||
return getAudioContext().currentTime;
|
||||
}
|
||||
|
||||
@@ -1,41 +0,0 @@
|
||||
/*
|
||||
clockbridge.mjs
|
||||
Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/src/branch/main/packages/superdough/index.mjs>
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
// thanks freya https://youtu.be/LSNQuFEDOyQ?si=ukZI2IGgWV_NDZzP&t=2979
|
||||
export function expDecay(a, b, decay, dt) {
|
||||
return b + (a - b) * Math.exp(-decay * dt);
|
||||
}
|
||||
|
||||
// translates between audio and performance clock
|
||||
export class ClockBridge {
|
||||
p; // smoothed clock offset
|
||||
lastTime;
|
||||
audioContext;
|
||||
constructor(audioContext) {
|
||||
this.audioContext = audioContext;
|
||||
}
|
||||
// delta between audio and performance time in ms
|
||||
getOffset() {
|
||||
const { contextTime, performanceTime } = this.audioContext.getOutputTimestamp();
|
||||
if (!contextTime || !performanceTime) {
|
||||
return;
|
||||
}
|
||||
const offset = performanceTime - contextTime * 1000; // clock offset in ms
|
||||
const dt = performanceTime - (this.lastTime ?? performanceTime); // delta time since last hap
|
||||
const decay = 1 / 10000; // how fast offset changes have an effect
|
||||
this.p = expDecay(this.p ?? offset, offset, decay, dt); // smooth clock offset
|
||||
this.lastTime = performanceTime;
|
||||
return this.p;
|
||||
}
|
||||
getPerformanceTime(audioContextTime) {
|
||||
const offset = this.getOffset();
|
||||
return audioContextTime * 1000 + offset; // this is now correct in performance time (ms)
|
||||
}
|
||||
getAudioContextTime(performanceTime) {
|
||||
const offset = this.getOffset();
|
||||
return (performanceTime - offset) / 1000; // this is now correct in audio context time (seconds)
|
||||
}
|
||||
}
|
||||
@@ -67,14 +67,13 @@ if (typeof window !== 'undefined') {
|
||||
});
|
||||
}
|
||||
|
||||
export const rawdsp = async (code) => {
|
||||
export const dough = async (code) => {
|
||||
const ac = getAudioContext();
|
||||
stop();
|
||||
worklet = await dspWorklet(ac, code);
|
||||
worklet.node.connect(ac.destination);
|
||||
};
|
||||
|
||||
export function rawdspOutput(hap, time, cps) {
|
||||
const currentTime = getAudioContext().currentTime;
|
||||
window.postMessage({ time, dough: hap.value, currentTime, duration: hap.duration, cps });
|
||||
export function doughTrigger(hap, currentTime, cps, targetTime) {
|
||||
window.postMessage({ time: targetTime, dough: hap.value, currentTime, duration: hap.duration, cps });
|
||||
}
|
||||
|
||||
@@ -6,27 +6,12 @@ import { clamp, nanFallback, midiToFreq, noteToMidi } from './util.mjs';
|
||||
|
||||
export const noises = ['pink', 'white', 'brown', 'crackle'];
|
||||
|
||||
export function gainNode(value, audioContext = getAudioContext()) {
|
||||
const node = audioContext.createGain();
|
||||
export function gainNode(value) {
|
||||
const node = getAudioContext().createGain();
|
||||
node.gain.value = value;
|
||||
return node;
|
||||
}
|
||||
|
||||
// this helper makes sure the audio context is "used", meaning it outputs something
|
||||
// this prevents the browser from throttling timing accuracy
|
||||
// it happened when only midi was running, the clock got more drifty without this
|
||||
let constantNode, constantNodeAudioContext;
|
||||
export function ensureMinimalOutput() {
|
||||
if (constantNode && constantNodeAudioContext === getAudioContext()) {
|
||||
return;
|
||||
}
|
||||
constantNodeAudioContext = getAudioContext();
|
||||
constantNode = new ConstantSourceNode(constantNodeAudioContext);
|
||||
constantNode.offset.value = 1e-7;
|
||||
constantNode.connect(constantNodeAudioContext.destination);
|
||||
constantNode.start();
|
||||
}
|
||||
|
||||
export function effectSend(input, effect, wet) {
|
||||
const send = gainNode(wet);
|
||||
input.connect(send);
|
||||
@@ -389,7 +374,7 @@ export function webAudioTimeout(audioContext, onComplete, startTime, stopTime) {
|
||||
|
||||
// Certain browsers requires audio nodes to be connected in order for their onended events
|
||||
// to fire, so we _mute it_ and then connect it to the destination
|
||||
const zeroGain = gainNode(0, audioContext);
|
||||
const zeroGain = gainNode(0);
|
||||
zeroGain.connect(audioContext.destination);
|
||||
constantNode.connect(zeroGain);
|
||||
|
||||
|
||||
@@ -14,4 +14,3 @@ export * from './modulators.mjs';
|
||||
export * from './dspworklet.mjs';
|
||||
export * from './audioContext.mjs';
|
||||
export * from './wavetable.mjs';
|
||||
export * from './clockbridge.mjs';
|
||||
|
||||
@@ -5,24 +5,11 @@ Copyright (C) 2025 Strudel contributors - see <https://codeberg.org/uzu/strudel/
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
import { releaseAudioNode } from './helpers.mjs';
|
||||
|
||||
const nodePools = new Map();
|
||||
const POOL_KEY = Symbol('nodePoolKey');
|
||||
|
||||
export const isPoolable = (node) => !!node[POOL_KEY];
|
||||
|
||||
export const clearNodePool = () => {
|
||||
for (const pool of nodePools) {
|
||||
for (const node of pool) {
|
||||
if (node instanceof AudioNode) {
|
||||
releaseAudioNode(node);
|
||||
}
|
||||
}
|
||||
}
|
||||
nodePools.clear();
|
||||
};
|
||||
|
||||
const getNodeTime = (node) => {
|
||||
return node.context?.currentTime ?? 0;
|
||||
};
|
||||
|
||||
@@ -36,9 +36,8 @@ function humanFileSize(bytes, si) {
|
||||
*
|
||||
* Note: `must` be called with await, otherwise you'll get a pending Promise object.
|
||||
*
|
||||
* @name getDuration
|
||||
* @synonym getDur
|
||||
* @tags samples
|
||||
* @name getDuration,getDur
|
||||
* @tag samples
|
||||
* @param {string} sampleName
|
||||
* @param {number} (optional) n
|
||||
*
|
||||
|
||||
@@ -1048,3 +1048,7 @@ export const superdough = async (value, t, hapDuration, cps = 0.5, cycle = 0.5)
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
export const superdoughTrigger = (t, hap, ct, cps) => {
|
||||
superdough(hap, t - ct, hap.duration / cps, cps);
|
||||
};
|
||||
|
||||
@@ -137,14 +137,7 @@ export const { transpose, trans } = register(['transpose', 'trans'], function tr
|
||||
const interval = !isNaN(Number(intervalOrSemitones))
|
||||
? Interval.fromSemitones(intervalOrSemitones)
|
||||
: String(intervalOrSemitones);
|
||||
|
||||
let n = Note.get(note);
|
||||
if (n.oct == undefined) {
|
||||
n.oct = 3;
|
||||
let n1 = Note.get(Note.transpose(n, interval));
|
||||
n.oct = n1.oct == 3 ? undefined : 3;
|
||||
}
|
||||
const targetNote = Note.transpose(n, interval);
|
||||
const targetNote = Note.transpose(note, interval);
|
||||
if (typeof hap.value === 'object') {
|
||||
return hap.withValue(() => ({ ...hap.value, note: targetNote }));
|
||||
}
|
||||
|
||||
@@ -134,16 +134,6 @@ let modeTarget = {
|
||||
duck: (v) => v.slice(-1)[0],
|
||||
above: (v) => v[0],
|
||||
root: (v) => v[0],
|
||||
oldabove: (v) => v[0],
|
||||
oldroot: (v) => v[0],
|
||||
};
|
||||
let modeMult = {
|
||||
below: 1,
|
||||
duck: 1,
|
||||
above: -1,
|
||||
root: -1,
|
||||
oldabove: 1,
|
||||
oldroot: 1,
|
||||
};
|
||||
|
||||
export function renderVoicing({ chord, dictionary, offset = 0, n, mode = 'below', anchor = 'c5', octaves = 1 }) {
|
||||
@@ -154,20 +144,19 @@ export function renderVoicing({ chord, dictionary, offset = 0, n, mode = 'below'
|
||||
const voicings = dictionary[symbol].map((voicing) =>
|
||||
(typeof voicing === 'string' ? voicing.split(' ') : voicing).map(step2semitones),
|
||||
);
|
||||
const mult = modeMult[mode];
|
||||
|
||||
let minDistance, bestIndex;
|
||||
// calculate distances up from voicing top notes
|
||||
let chromaDiffs = voicings.map((v, i) => {
|
||||
const targetStep = modeTarget[mode](v);
|
||||
const diff = _mod((anchorChroma - targetStep - rootChroma) * mult, 12);
|
||||
const diff = _mod(anchorChroma - targetStep - rootChroma, 12);
|
||||
if (minDistance === undefined || diff < minDistance) {
|
||||
minDistance = diff;
|
||||
bestIndex = i;
|
||||
}
|
||||
return diff * mult;
|
||||
return diff;
|
||||
});
|
||||
if (mode === 'root' || mode === 'oldroot') {
|
||||
if (mode === 'root') {
|
||||
bestIndex = 0;
|
||||
}
|
||||
|
||||
|
||||
@@ -185,9 +185,6 @@ export const rootNotes = register('rootNotes', function (octave, pat) {
|
||||
* - `below`: top note <= anchor
|
||||
* - `duck`: top note <= anchor, anchor excluded
|
||||
* - `above`: bottom note >= anchor
|
||||
* - `root`: bottom note is the lowest root of the chord >= anchor
|
||||
* - `oldabove` : old (buggy) behavior of above, kept for legacy reason
|
||||
* - `oldroot` : old (buggy) behavior of root, kept for legacy reason
|
||||
* - `offset`: whole number that shifts the voicing up or down to the next voicing
|
||||
* - `n`: if set, the voicing is played like a scale. Overshooting numbers will be octaved
|
||||
*
|
||||
|
||||
@@ -6,7 +6,7 @@ export * from '@strudel/mini';
|
||||
export * from '@strudel/edo';
|
||||
export * from '@strudel/tonal';
|
||||
export * from '@strudel/webaudio';
|
||||
import { Pattern, evalScope, setTime, setClockTime } from '@strudel/core';
|
||||
import { Pattern, evalScope, setTime } from '@strudel/core';
|
||||
import { initAudioOnFirstClick, registerSynthSounds, webaudioRepl } from '@strudel/webaudio';
|
||||
// import { registerSoundfonts } from '@strudel/soundfonts';
|
||||
import { evaluate as _evaluate, transpiler } from '@strudel/transpiler';
|
||||
@@ -41,7 +41,6 @@ export function initStrudel(options = {}) {
|
||||
return repl;
|
||||
})();
|
||||
setTime(() => repl.scheduler.now());
|
||||
setClockTime(() => repl.scheduler.getTime()); // TODO: refactor?
|
||||
return initDone;
|
||||
}
|
||||
|
||||
|
||||
@@ -19,7 +19,7 @@ initAudioOnFirstClick();
|
||||
const ctx = getAudioContext();
|
||||
|
||||
const { scheduler } = repl({
|
||||
onSchedule: webaudioOutput,
|
||||
defaultOutput: webaudioOutput,
|
||||
getTime: () => ctx.currentTime
|
||||
});
|
||||
|
||||
|
||||
@@ -20,7 +20,7 @@ const soundMap = new Map();
|
||||
const loadedSounds = new Map();
|
||||
|
||||
Pattern.prototype.supradough = function () {
|
||||
return this.onSchedule((hap, begin, cps) => {
|
||||
return this.onTrigger((hap, __, cps, begin) => {
|
||||
hap.value._begin = begin;
|
||||
hap.value._duration = hap.duration / cps;
|
||||
!doughWorklet && initDoughWorklet();
|
||||
@@ -61,7 +61,7 @@ function githubPath(base, subpath = '') {
|
||||
}
|
||||
return `https://raw.githubusercontent.com/${path}/${subpath}`;
|
||||
}
|
||||
export async function _fetchSampleMap(url) {
|
||||
export async function fetchSampleMap(url) {
|
||||
if (url.startsWith('github:')) {
|
||||
url = githubPath(url, 'strudel.json');
|
||||
}
|
||||
@@ -114,11 +114,11 @@ async function fetchSample(url) {
|
||||
return { channels, sampleRate: buffer.sampleRate };
|
||||
}
|
||||
|
||||
export async function supradoughsamples(sampleMap, baseUrl) {
|
||||
export async function doughsamples(sampleMap, baseUrl) {
|
||||
if (typeof sampleMap === 'string') {
|
||||
const [json, base] = await _fetchSampleMap(sampleMap);
|
||||
const [json, base] = await fetchSampleMap(sampleMap);
|
||||
// console.log('json', json, 'base', base);
|
||||
return supradoughsamples(json, base);
|
||||
return doughsamples(json, base);
|
||||
}
|
||||
Object.entries(sampleMap).map(async ([key, urls]) => {
|
||||
if (key !== '_base') {
|
||||
|
||||
@@ -9,7 +9,7 @@ import {
|
||||
superdough,
|
||||
getAudioContext,
|
||||
setLogger,
|
||||
rawdspOutput,
|
||||
doughTrigger,
|
||||
registerWorklet,
|
||||
setAudioContext,
|
||||
initAudio,
|
||||
@@ -32,8 +32,8 @@ const hap2value = (hap) => {
|
||||
};
|
||||
|
||||
// uses more precise, absolute t if available, see https://github.com/tidalcycles/strudel/pull/1004
|
||||
export const webaudioOutput = (hap, t, cps) => {
|
||||
const hapDuration = hap.duration / cps;
|
||||
// TODO: refactor output callbacks to eliminate deadline
|
||||
export const webaudioOutput = (hap, _deadline, hapDuration, cps, t) => {
|
||||
return superdough(hap2value(hap), t, hapDuration, cps, hap.whole?.begin.valueOf());
|
||||
};
|
||||
|
||||
@@ -56,14 +56,32 @@ export async function renderPatternAudio(
|
||||
maxPolyphony,
|
||||
multiChannelOrbits,
|
||||
});
|
||||
logger('[webaudio] preloading');
|
||||
|
||||
// Firefox currently doesn't support suspending an OfflineAudioContext,
|
||||
// so no chunked rendering. Bad performance, but at least it works.
|
||||
return (
|
||||
audioContext.suspend === undefined
|
||||
? renderPatternAudioWhole(audioContext, pattern, cps, begin, end)
|
||||
: renderPatternAudioInChunks(audioContext, pattern, cps, begin, end, 1)
|
||||
)
|
||||
// Calling superdough(...) in ascending onset time order is important
|
||||
// for controls that depend on the audio graph state like `cut`
|
||||
let haps = pattern
|
||||
.queryArc(begin, end, { _cps: cps })
|
||||
.sort((a, b) => a.whole.begin.valueOf() - b.whole.begin.valueOf());
|
||||
for (const hap of haps) {
|
||||
if (hap.hasOnset()) {
|
||||
try {
|
||||
await superdough(
|
||||
hap2value(hap),
|
||||
(hap.whole.begin.valueOf() - begin) / cps,
|
||||
hap.duration / cps,
|
||||
cps,
|
||||
(hap.whole?.begin.valueOf() - begin) / cps,
|
||||
);
|
||||
} catch (err) {
|
||||
errorLogger(err, 'webaudio');
|
||||
}
|
||||
}
|
||||
}
|
||||
logger('[webaudio] start rendering');
|
||||
|
||||
return audioContext
|
||||
.startRendering()
|
||||
.then((renderedBuffer) => {
|
||||
const wavBuffer = audioBufferToWav(renderedBuffer);
|
||||
const blob = new Blob([wavBuffer], { type: 'audio/wav' });
|
||||
@@ -84,97 +102,19 @@ export async function renderPatternAudio(
|
||||
});
|
||||
}
|
||||
|
||||
async function renderPatternAudioWhole(audioContext, pattern, cps, begin, end) {
|
||||
logger(`[webaudio] preloading`);
|
||||
|
||||
await scheduleHapsChunk(pattern, cps, begin, begin, end);
|
||||
|
||||
logger('[webaudio] start rendering');
|
||||
|
||||
return audioContext.startRendering();
|
||||
}
|
||||
|
||||
async function renderPatternAudioInChunks(audioContext, pattern, cps, begin, end, chunkSizeInCycles) {
|
||||
let currentCycle = begin;
|
||||
let renderPromise = null;
|
||||
|
||||
logger('[webaudio] start rendering');
|
||||
|
||||
while (currentCycle <= end) {
|
||||
const chunkStart = currentCycle;
|
||||
const chunkEnd = Math.min(currentCycle + chunkSizeInCycles, end);
|
||||
|
||||
logger(`[webaudio] preloading cycles ${chunkStart} - ${chunkEnd}`);
|
||||
|
||||
await scheduleHapsChunk(pattern, cps, begin, chunkStart, chunkEnd);
|
||||
|
||||
logger(`[webaudio] rendering cycles ${chunkStart} - ${chunkEnd}`);
|
||||
|
||||
currentCycle += chunkSizeInCycles;
|
||||
|
||||
// According to the MDN docs, suspends should be scheduled while
|
||||
// the audioContext is not currently running for better precision.
|
||||
// So we schedule the suspend first, and await after resuming.
|
||||
var suspendPromise;
|
||||
if (currentCycle < end) {
|
||||
// Make sure to suspend one cycle before the next currentCycle
|
||||
// so the next haps can be scheduled on time.
|
||||
suspendPromise = audioContext.suspend((currentCycle - begin - 1) / cps);
|
||||
}
|
||||
|
||||
if (renderPromise === null) {
|
||||
renderPromise = audioContext.startRendering();
|
||||
} else {
|
||||
await audioContext.resume();
|
||||
}
|
||||
|
||||
if (currentCycle < end) {
|
||||
await suspendPromise;
|
||||
}
|
||||
}
|
||||
|
||||
logger('[webaudio] finish rendering');
|
||||
|
||||
return renderPromise;
|
||||
}
|
||||
|
||||
async function scheduleHapsChunk(pattern, cps, begin, chunkStart, chunkEnd) {
|
||||
// Calling superdough(...) in ascending onset time order is important
|
||||
// for controls that depend on the audio graph state like `cut`
|
||||
let haps = pattern
|
||||
.queryArc(chunkStart, chunkEnd, { _cps: cps })
|
||||
.sort((a, b) => a.whole.begin.valueOf() - b.whole.begin.valueOf());
|
||||
|
||||
for (const hap of haps) {
|
||||
if (hap.hasOnset()) {
|
||||
try {
|
||||
await superdough(
|
||||
hap2value(hap),
|
||||
(hap.whole.begin.valueOf() - begin) / cps,
|
||||
hap.duration / cps,
|
||||
cps,
|
||||
(hap.whole?.begin.valueOf() - begin) / cps,
|
||||
);
|
||||
} catch (err) {
|
||||
errorLogger(err, 'webaudio');
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export function webaudioRepl(options = {}) {
|
||||
const audioContext = options.audioContext ?? getAudioContext();
|
||||
setAudioContext(audioContext);
|
||||
options = {
|
||||
getTime: () => audioContext.currentTime,
|
||||
onSchedule: webaudioOutput,
|
||||
defaultOutput: webaudioOutput,
|
||||
...options,
|
||||
};
|
||||
return repl(options);
|
||||
}
|
||||
|
||||
Pattern.prototype.rawdsp = function () {
|
||||
return this.onSchedule(rawdspOutput, 1);
|
||||
Pattern.prototype.dough = function () {
|
||||
return this.onTrigger(doughTrigger, 1);
|
||||
};
|
||||
|
||||
function audioBufferToWav(buffer, opt) {
|
||||
|
||||
@@ -8,14 +8,11 @@ import Tune from './tunejs.js';
|
||||
import { register } from '@strudel/core';
|
||||
|
||||
/**
|
||||
* Deprecated.
|
||||
*
|
||||
* Assumes pattern contains numerical scale degrees on the `i` control (see examples below). Accepts a scale name or list of frequencies (see all available names at the link on the reference). Returns a new pattern with all values mapped to a frequency ratio. Similar to `xen`.
|
||||
* @name tune
|
||||
* @returns Pattern
|
||||
* @memberof Pattern
|
||||
* @param {(string | number[] )} scale
|
||||
* @deprecated
|
||||
* @example
|
||||
* i("0 1 2 3 4 5").tune("hexany15").mul("220").freq()
|
||||
* @example
|
||||
|
||||
+29
-105
@@ -4,7 +4,7 @@ Copyright (C) 2022 Strudel contributors - see <https://codeberg.org/uzu/strudel/
|
||||
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
import { register, _mod, parseNumeral, removeUndefineds, Pattern, parray, State } from '@strudel/core';
|
||||
import { register, _mod, parseNumeral, removeUndefineds } from '@strudel/core';
|
||||
import Tune from './tunejs.js';
|
||||
|
||||
// returns a list of frequency ratios for given edo scale
|
||||
@@ -61,8 +61,14 @@ function xenOffset(xenScale, offset, index = 0) {
|
||||
|
||||
const trimFreq = (freq) => parseFloat(freq.toPrecision(10));
|
||||
|
||||
// accepts a scale name such as 31edo, and a pattern
|
||||
// pattern expected to follow format such that a value can be mapped
|
||||
// to an edostep within the scale. Returns the pattern with
|
||||
// values mapped to the frequencies associated with the given edosteps
|
||||
// scaleNameOrRatios: string || number[], steps?: number
|
||||
|
||||
/**
|
||||
* Assumes a numerical pattern of scale steps, and a scale. Scales accepted are all preset scale names of `tune`, arbitrary edos such as 31edo, or an array of frequency ratios. Assumes scales repeat at octave (2/1). Returns a new pattern with all values mapped to their associated frequency, assuming a base frequency of 220hz. See first 4 examples for the different ways you can input a scale into `xen`
|
||||
* Assumes a numerical pattern of scale steps, and a scale. Scales accepted are all preset scale names of `tune`, arbitrary edos such as 31edo, or an array of frequency ratios. Assumes scales repeat at octave (2/1). Returns a new pattern with all values mapped to their associated frequency, assuming a base frequency of 220hz.
|
||||
*
|
||||
* @name xen
|
||||
* @returns Pattern
|
||||
@@ -81,15 +87,6 @@ const trimFreq = (freq) => parseFloat(freq.toPrecision(10));
|
||||
* Math.pow(2, 18/31),
|
||||
* ]).piano()
|
||||
* @example
|
||||
* // However, with the above you won't get highlighting of the scale indices,
|
||||
* // instead you could do something like:
|
||||
* i("[<2 ->, 0 1 <- 2> 3]*2").xen([
|
||||
* "1:1", // tonic
|
||||
* "5:4", // Major 3rd
|
||||
* "[3:2 4:3]", // Perfect 5th, 4th
|
||||
* "5:3" // Major 6th
|
||||
* ]).s("tri")
|
||||
* @example
|
||||
* // xen also supports all scale names that
|
||||
* // tune does:
|
||||
* i("0 1 2 3 4 5").xen("hexany15")
|
||||
@@ -99,100 +96,27 @@ const trimFreq = (freq) => parseFloat(freq.toPrecision(10));
|
||||
* i("0 1 2 3 4 5 6 7").xen("<5edo 10edo 15edo hexany15>")
|
||||
*/
|
||||
|
||||
export const xen = register(
|
||||
'xen',
|
||||
function (scaleNameOrRatios, pat) {
|
||||
const JIsc2 = (input) => {
|
||||
let k = parray(input);
|
||||
|
||||
return new Pattern((state) => {
|
||||
let res = k.withValue((x) => x.map((y) => y.reduce((acc, v) => acc / v))).query(state);
|
||||
return res;
|
||||
});
|
||||
};
|
||||
|
||||
const query = (state) => {
|
||||
let haps = pat.query(state);
|
||||
let resHaps = [];
|
||||
|
||||
haps.forEach((hap) => {
|
||||
let hVal = hap.value;
|
||||
const isObject = typeof hVal === 'object';
|
||||
if (!isObject) {
|
||||
throw new Error(
|
||||
`Expected hap to have control 'i' set, but received ${hap.value.i}, try wrapping input in i()`,
|
||||
);
|
||||
}
|
||||
const { i, ...otherValues } = hVal;
|
||||
let edo = false;
|
||||
let st = new State(hap.wholeOrPart().intersection(state.span), state.controls);
|
||||
|
||||
// Format: An array of values
|
||||
// Each value is a pattern, representing an index on the scale
|
||||
let sc = scaleNameOrRatios.query(st);
|
||||
// Check to see if input is attempting to be a named scale or a raw scale
|
||||
let isStr = typeof sc[0].value == 'string';
|
||||
let isRawScale = Array.isArray(sc[0].value) && sc[0].value.every((x) => typeof x == 'number');
|
||||
if (!isStr && !isRawScale) {
|
||||
sc = sc[0].value;
|
||||
} else if (isRawScale) {
|
||||
sc = getXenScale(sc[0].value);
|
||||
}
|
||||
|
||||
if (!isStr && !isRawScale) {
|
||||
let scaleByIndices = [];
|
||||
for (let j = 0; j < sc.length; j++) {
|
||||
scaleByIndices[j] = sc[j].query(st);
|
||||
}
|
||||
/*
|
||||
Format: An array of 1 or more Haps, each Hap has an array of values of
|
||||
one or more scale index definitions (contains whole scale)
|
||||
Assumption: inner value array should be same length between each
|
||||
*/
|
||||
let sc2 = JIsc2(sc).query(st);
|
||||
|
||||
let index = _mod(i, sc.length);
|
||||
for (let j = 0; j < scaleByIndices[index].length; j++) {
|
||||
let scale = getXenScale(sc2[j].value);
|
||||
let freq = xenOffset(scale, parseNumeral(i));
|
||||
let newHap = hap;
|
||||
freq = trimFreq(freq);
|
||||
newHap.value = { ...otherValues, freq };
|
||||
newHap = newHap.setContext(newHap.combineContext(scaleByIndices[index][j]));
|
||||
resHaps.push(newHap);
|
||||
}
|
||||
} else if (isRawScale) {
|
||||
let freq = xenOffset(sc, parseNumeral(i));
|
||||
let newHap = hap;
|
||||
freq = trimFreq(freq);
|
||||
newHap.value = { ...otherValues, freq };
|
||||
resHaps.push(newHap);
|
||||
} else if (isStr) {
|
||||
// scale is named scale(s)
|
||||
for (let j = 0; j < sc.length; j++) {
|
||||
let scaleName = sc[j].value;
|
||||
let scale = getXenScale(scaleName);
|
||||
let freq = xenOffset(scale, parseNumeral(i));
|
||||
let newHap = hap;
|
||||
freq = trimFreq(freq);
|
||||
newHap.value = { ...otherValues, freq };
|
||||
newHap = newHap.setContext(newHap.combineContext(sc[j]));
|
||||
if (isEdo(scaleName)) {
|
||||
edo = scaleName.match(/^([1-9]+[0-9]*)edo$/)[1];
|
||||
newHap = newHap.setContext({ ...newHap.context, edoSize: edo });
|
||||
}
|
||||
resHaps.push(newHap);
|
||||
}
|
||||
} else {
|
||||
throw new Error('failed to parse scale');
|
||||
}
|
||||
});
|
||||
return resHaps;
|
||||
};
|
||||
return new Pattern(query);
|
||||
},
|
||||
false,
|
||||
);
|
||||
export const xen = register('xen', function (scaleNameOrRatios, pat) {
|
||||
return pat.withHaps((haps) => {
|
||||
haps = haps.map((hap) => {
|
||||
let hVal = hap.value;
|
||||
const isObject = typeof hVal === 'object';
|
||||
if (!isObject) {
|
||||
throw new Error(`Expected hap to have control 'i' set, but received ${hap.value.i}, try wrapping input in i()`);
|
||||
}
|
||||
const { i, ...otherValues } = hVal;
|
||||
const scale = getXenScale(scaleNameOrRatios);
|
||||
let freq = xenOffset(scale, parseNumeral(hVal.i));
|
||||
// 10 is somewhat arbitrary
|
||||
freq = trimFreq(freq);
|
||||
hap.value = { ...otherValues, freq };
|
||||
return isEdo(scaleNameOrRatios)
|
||||
? hap.setContext({ ...hap.context, edoSize: scaleNameOrRatios.match(/^([1-9]+[0-9]*)edo$/)[1] })
|
||||
: hap;
|
||||
});
|
||||
return removeUndefineds(haps);
|
||||
});
|
||||
});
|
||||
|
||||
/**
|
||||
* Assumes pattern of frequencies tuned to some `base` frequency, such as the output of `xen`
|
||||
|
||||
Generated
+1
-46
@@ -299,32 +299,10 @@ importers:
|
||||
'@strudel/core':
|
||||
specifier: workspace:*
|
||||
version: link:../core
|
||||
'@strudel/osc':
|
||||
specifier: workspace:*
|
||||
version: link:../osc
|
||||
'@strudel/webaudio':
|
||||
specifier: workspace:*
|
||||
version: link:../webaudio
|
||||
'@tauri-apps/api':
|
||||
specifier: ^2.2.0
|
||||
version: 2.2.0
|
||||
|
||||
packages/dough:
|
||||
dependencies:
|
||||
'@strudel/core':
|
||||
specifier: workspace:*
|
||||
version: link:../core
|
||||
'@strudel/webaudio':
|
||||
specifier: workspace:*
|
||||
version: link:../webaudio
|
||||
dough-synth:
|
||||
specifier: 0.2.4
|
||||
version: 0.2.4
|
||||
devDependencies:
|
||||
vite:
|
||||
specifier: ^6.0.11
|
||||
version: 6.0.11(@types/node@22.10.10)(jiti@2.4.2)(lightningcss@1.29.1)(terser@5.37.0)(yaml@2.7.0)
|
||||
|
||||
packages/draw:
|
||||
dependencies:
|
||||
'@strudel/core':
|
||||
@@ -492,9 +470,6 @@ importers:
|
||||
'@strudel/core':
|
||||
specifier: workspace:*
|
||||
version: link:../core
|
||||
'@strudel/webaudio':
|
||||
specifier: workspace:*
|
||||
version: link:../webaudio
|
||||
osc:
|
||||
specifier: ^2.4.5
|
||||
version: 2.4.5
|
||||
@@ -833,9 +808,6 @@ importers:
|
||||
'@strudel/desktopbridge':
|
||||
specifier: workspace:*
|
||||
version: link:../packages/desktopbridge
|
||||
'@strudel/dough':
|
||||
specifier: workspace:*
|
||||
version: link:../packages/dough
|
||||
'@strudel/draw':
|
||||
specifier: workspace:*
|
||||
version: link:../packages/draw
|
||||
@@ -2094,7 +2066,6 @@ packages:
|
||||
'@lerna/create@8.1.9':
|
||||
resolution: {integrity: sha512-DPnl5lPX4v49eVxEbJnAizrpMdMTBz1qykZrAbBul9rfgk531v8oAt+Pm6O/rpAleRombNM7FJb5rYGzBJatOQ==}
|
||||
engines: {node: '>=18.0.0'}
|
||||
deprecated: This package is an implementation detail of Lerna and is no longer published separately.
|
||||
|
||||
'@lezer/common@1.2.3':
|
||||
resolution: {integrity: sha512-w7ojc8ejBqr2REPsWxJjrMFsA/ysDCFICn8zEOR9mrqzOu2amhITYuLD8ag6XZf0CFXDrhKqw7+tW8cX66NaDA==}
|
||||
@@ -3094,7 +3065,6 @@ packages:
|
||||
|
||||
'@ungap/structured-clone@1.3.0':
|
||||
resolution: {integrity: sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==}
|
||||
deprecated: Potential CWE-502 - Update to 1.3.1 or higher
|
||||
|
||||
'@vite-pwa/astro@0.5.0':
|
||||
resolution: {integrity: sha512-Yd3Pug/c1EUQJXWvzYh6eTtoqzmSKcdCqWCcNquZeaD13tLWpBb2FIPJ4HMULVY6+GfxMvrT+OBuMrbHQCvftw==}
|
||||
@@ -3746,7 +3716,6 @@ packages:
|
||||
conventional-changelog-core@5.0.1:
|
||||
resolution: {integrity: sha512-Rvi5pH+LvgsqGwZPZ3Cq/tz4ty7mjijhr3qR4m9IBXNbxGGYgTVVO+duXzz9aArmHxFtwZ+LRkrNIMDQzgoY4A==}
|
||||
engines: {node: '>=14'}
|
||||
deprecated: Deprecated and no longer maintained. Please use conventional-changelog instead.
|
||||
|
||||
conventional-changelog-preset-loader@3.0.0:
|
||||
resolution: {integrity: sha512-qy9XbdSLmVnwnvzEisjxdDiLA4OmV3o8db+Zdg4WiFw14fP3B6XNz98X0swPPpkTd/pc1K7+adKgEDM1JCUMiA==}
|
||||
@@ -4078,10 +4047,6 @@ packages:
|
||||
resolution: {integrity: sha512-47qPchRCykZC03FhkYAhrvwU4xDBFIj1QPqaarj6mdM/hgUzfPHcpkHJOn3mJAufFeeAxAzeGsr5X0M4k6fLZQ==}
|
||||
engines: {node: '>=12'}
|
||||
|
||||
dough-synth@0.2.4:
|
||||
resolution: {integrity: sha512-qMnMKVj1B2ivUgobNCwqJqNzZHOMN+5339OmCOk07zIDEK7iCYdufa+ZDE2BEgmKrWDyhGS7oTNFjHtTwzEv9w==}
|
||||
hasBin: true
|
||||
|
||||
dset@3.1.4:
|
||||
resolution: {integrity: sha512-2QF/g9/zTaPDc3BjNcVTGoBbXBgYfMTTceLaYcFJ/W9kggFUkhxD/hMEeuLKbugyef9SqAx8cpgwlIP/jinUTA==}
|
||||
engines: {node: '>=4'}
|
||||
@@ -4614,7 +4579,6 @@ packages:
|
||||
git-raw-commits@3.0.0:
|
||||
resolution: {integrity: sha512-b5OHmZ3vAgGrDn/X0kS+9qCfNKWe4K/jFnhwzVWWg0/k5eLa3060tZShrRg8Dja5kPc+YjS0Gc6y7cRr44Lpjw==}
|
||||
engines: {node: '>=14'}
|
||||
deprecated: Deprecated and no longer maintained. Use @conventional-changelog/git-client instead.
|
||||
hasBin: true
|
||||
|
||||
git-remote-origin-url@2.0.0:
|
||||
@@ -4624,7 +4588,6 @@ packages:
|
||||
git-semver-tags@5.0.1:
|
||||
resolution: {integrity: sha512-hIvOeZwRbQ+7YEUmCkHqo8FOLQZCEn18yevLHADlFPZY02KJGsu5FZt9YW/lybfK2uhWFI7Qg/07LekJiTv7iA==}
|
||||
engines: {node: '>=14'}
|
||||
deprecated: Deprecated and no longer maintained. Use @conventional-changelog/git-client instead.
|
||||
hasBin: true
|
||||
|
||||
git-up@7.0.0:
|
||||
@@ -4652,17 +4615,15 @@ packages:
|
||||
|
||||
glob@10.4.5:
|
||||
resolution: {integrity: sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==}
|
||||
deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
|
||||
hasBin: true
|
||||
|
||||
glob@7.2.3:
|
||||
resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==}
|
||||
deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
|
||||
deprecated: Glob versions prior to v9 are no longer supported
|
||||
|
||||
glob@9.3.5:
|
||||
resolution: {integrity: sha512-e1LleDykUz2Iu+MTYdkSsuWX8lvAjAcs0Xef0lNIu0S2wOAzuTxCJtcd9S3cijlwYF18EsU3rzb8jPVobxDh9Q==}
|
||||
engines: {node: '>=16 || 14 >=14.17'}
|
||||
deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
|
||||
|
||||
globalize@0.1.1:
|
||||
resolution: {integrity: sha512-5e01v8eLGfuQSOvx2MsDMOWS0GFtCx1wPzQSmcHw4hkxFzrQDBO3Xwg/m8Hr/7qXMrHeOIE29qWVzyv06u1TZA==}
|
||||
@@ -6445,7 +6406,6 @@ packages:
|
||||
prebuild-install@7.1.1:
|
||||
resolution: {integrity: sha512-jAXscXWMcCK8GgCoHOfIr0ODh5ai8mj63L2nWrjuAgXE6tDyYGnx4/8o/rCgU+B4JSyZBKbeZqzhtwtC3ovxjw==}
|
||||
engines: {node: '>=10'}
|
||||
deprecated: No longer maintained. Please contact the author of the relevant native addon; alternatives are available.
|
||||
hasBin: true
|
||||
|
||||
precinct@12.1.2:
|
||||
@@ -7270,7 +7230,6 @@ packages:
|
||||
tar@6.2.1:
|
||||
resolution: {integrity: sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==}
|
||||
engines: {node: '>=10'}
|
||||
deprecated: Old versions of tar are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
|
||||
|
||||
temp-dir@1.0.0:
|
||||
resolution: {integrity: sha512-xZFXEGbG7SNC3itwBzI3RYjq/cEhBkx2hJuKGIUOcEULmkQExXiHat2z/qkISYsuR+IKumhEfKKbV5qXmhICFQ==}
|
||||
@@ -7398,7 +7357,6 @@ packages:
|
||||
tsconfck@3.1.4:
|
||||
resolution: {integrity: sha512-kdqWFGVJqe+KGYvlSO9NIaWn9jT1Ny4oKVzAJsKii5eoE9snzTJzL4+MMVOMn+fikWGFmKEylcXL710V/kIPJQ==}
|
||||
engines: {node: ^18 || >=20}
|
||||
deprecated: unmaintained
|
||||
hasBin: true
|
||||
peerDependencies:
|
||||
typescript: ^5.0.0
|
||||
@@ -7678,7 +7636,6 @@ packages:
|
||||
|
||||
uuid@10.0.0:
|
||||
resolution: {integrity: sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ==}
|
||||
deprecated: uuid@10 and below is no longer supported. For ESM codebases, update to uuid@latest. For CommonJS codebases, use uuid@11 (but be aware this version will likely be deprecated in 2028).
|
||||
hasBin: true
|
||||
|
||||
validate-npm-package-license@3.0.4:
|
||||
@@ -11800,8 +11757,6 @@ snapshots:
|
||||
|
||||
dotenv@16.4.7: {}
|
||||
|
||||
dough-synth@0.2.4: {}
|
||||
|
||||
dset@3.1.4: {}
|
||||
|
||||
dunder-proto@1.0.1:
|
||||
|
||||
+12
-13
@@ -4,19 +4,18 @@ packages:
|
||||
- tools/dbpatch
|
||||
- website/
|
||||
|
||||
catalog:
|
||||
'@codemirror/autocomplete': ^6.18.4
|
||||
'@codemirror/commands': ^6.8.0
|
||||
'@codemirror/lang-javascript': ^6.2.2
|
||||
'@codemirror/language': ^6.10.8
|
||||
'@codemirror/search': ^6.5.8
|
||||
'@codemirror/state': ^6.5.1
|
||||
'@codemirror/view': ^6.36.2
|
||||
|
||||
ignoredBuiltDependencies:
|
||||
- '@serialport/bindings-cpp'
|
||||
- tree-sitter-haskell
|
||||
- tree-sitter
|
||||
onlyBuiltDependencies:
|
||||
- esbuild
|
||||
- nx
|
||||
- sharp
|
||||
- tree-sitter
|
||||
- tree-sitter-haskell
|
||||
|
||||
catalog:
|
||||
"@codemirror/commands": "^6.8.0"
|
||||
"@codemirror/language": "^6.10.8"
|
||||
"@codemirror/lang-javascript": "^6.2.2"
|
||||
"@codemirror/state": "^6.5.1"
|
||||
"@codemirror/view": "^6.36.2"
|
||||
"@codemirror/autocomplete": "^6.18.4"
|
||||
"@codemirror/search": "^6.5.8"
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -7203,12 +7203,8 @@ exports[`renders tunes > tune: holyflute 1`] = `
|
||||
|
||||
exports[`renders tunes > tune: juxUndTollerei 1`] = `
|
||||
[
|
||||
"[ -99/200 ⇜ (0/1 → 1/200) | note:63 s:triangle pan:0 cutoff:758.852817928549 lpattack:0.2 lpenv:-2 decay:0.05 sustain:0 room:0.6 delay:0.5 delaytime:0.1 delayfeedback:0.4 ]",
|
||||
"[ -99/200 ⇜ (0/1 → 1/200) | note:67 s:triangle pan:1 color:green cutoff:758.852817928549 lpattack:0.2 lpenv:-2 decay:0.05 sustain:0 room:0.6 delay:0.5 delaytime:0.1 delayfeedback:0.4 ]",
|
||||
"[ 0/1 → 1/4 | note:c3 s:sawtooth pan:0 cutoff:1100 lpattack:0.2 lpenv:-2 decay:0.05 sustain:0 room:0.6 delay:0.5 delaytime:0.1 delayfeedback:0.4 ]",
|
||||
"[ 0/1 → 1/4 | note:bb3 s:sawtooth pan:1 color:green cutoff:1100 lpattack:0.2 lpenv:-2 decay:0.05 sustain:0 room:0.6 delay:0.5 delaytime:0.1 delayfeedback:0.4 ]",
|
||||
"[ 1/200 → 101/200 | note:55 s:triangle pan:0 cutoff:1103.534282651425 lpattack:0.2 lpenv:-2 decay:0.05 sustain:0 room:0.6 delay:0.5 delaytime:0.1 delayfeedback:0.4 ]",
|
||||
"[ 1/200 → 101/200 | note:65 s:triangle pan:1 color:green cutoff:1103.534282651425 lpattack:0.2 lpenv:-2 decay:0.05 sustain:0 room:0.6 delay:0.5 delaytime:0.1 delayfeedback:0.4 ]",
|
||||
"[ 1/4 → 1/2 | note:eb3 s:sawtooth pan:0 cutoff:1275.581289814515 lpattack:0.2 lpenv:-2 decay:0.05 sustain:0 room:0.6 delay:0.5 delaytime:0.1 delayfeedback:0.4 ]",
|
||||
"[ 1/4 → 1/2 | note:g3 s:sawtooth pan:1 color:green cutoff:1275.581289814515 lpattack:0.2 lpenv:-2 decay:0.05 sustain:0 room:0.6 delay:0.5 delaytime:0.1 delayfeedback:0.4 ]",
|
||||
"[ 1/2 → 3/4 | note:g3 s:sawtooth pan:0 cutoff:1444.415089128581 lpattack:0.2 lpenv:-2 decay:0.05 sustain:0 room:0.6 delay:0.5 delaytime:0.1 delayfeedback:0.4 ]",
|
||||
@@ -7322,12 +7318,12 @@ exports[`renders tunes > tune: randomBells 1`] = `
|
||||
[
|
||||
"[ -9/8 ⇜ (0/1 → 3/8) | gain:0.6 note:A3 velocity:0.598990320228 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ -3/4 ⇜ (0/1 → 3/4) | gain:0.6 note:C5 velocity:0.836992966942 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 0/1 → 3/2 | note:D2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 0/1 → 3/2 | note:F2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 0/1 → 9/4 | gain:0.6 note:D3 velocity:0.5 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 3/8 → 21/8 | gain:0.6 note:F5 velocity:0.921303892508 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 3/4 → 3/1 | gain:0.6 note:C5 velocity:0.842607785016 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 3/2 → 9/4 | note:D2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 9/4 → 3/1 | note:D2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 3/2 → 9/4 | note:F2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 9/4 → 3/1 | note:F2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 9/4 → 9/2 | gain:0.6 note:D4 velocity:0.700696257874 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 21/8 → 39/8 | gain:0.6 note:C4 velocity:0.650794394314 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 3/1 → 9/2 | note:D2 s:bass clip:1 gain:0.8 ]",
|
||||
@@ -7339,12 +7335,12 @@ exports[`renders tunes > tune: randomBells 1`] = `
|
||||
"[ (21/4 → 6/1) ⇝ 27/4 | gain:0.6 note:D4 velocity:0.698815540411 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 39/8 ⇜ (6/1 → 51/8) | gain:0.6 note:D5 velocity:0.875811336562 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 21/4 ⇜ (6/1 → 27/4) | gain:0.6 note:D4 velocity:0.698815540411 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 6/1 → 15/2 | note:A2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 6/1 → 15/2 | note:D2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 6/1 → 33/4 | gain:0.6 note:G4 velocity:0.75977108255 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 51/8 → 69/8 | gain:0.6 note:G4 velocity:0.774316444062 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 27/4 → 9/1 | gain:0.6 note:C5 velocity:0.836244757287 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 15/2 → 33/4 | note:A2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 33/4 → 9/1 | note:A2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 15/2 → 33/4 | note:D2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 33/4 → 9/1 | note:D2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 33/4 → 21/2 | gain:0.6 note:A3 velocity:0.59140187595 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 69/8 → 87/8 | gain:0.6 note:G4 velocity:0.754063542932 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 9/1 → 21/2 | note:A2 s:bass clip:1 gain:0.8 ]",
|
||||
@@ -7356,12 +7352,12 @@ exports[`renders tunes > tune: randomBells 1`] = `
|
||||
"[ (45/4 → 12/1) ⇝ 51/4 | gain:0.6 note:A4 velocity:0.797278589569 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 87/8 ⇜ (12/1 → 99/8) | gain:0.6 note:F4 velocity:0.734787144698 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 45/4 ⇜ (12/1 → 51/4) | gain:0.6 note:A4 velocity:0.797278589569 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 12/1 → 27/2 | note:G2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 12/1 → 27/2 | note:A2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 12/1 → 57/4 | gain:0.6 note:G5 velocity:0.979763559997 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 99/8 → 117/8 | gain:0.6 note:C4 velocity:0.666239210404 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 51/4 → 15/1 | gain:0.6 note:F5 velocity:0.95169514697 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 27/2 → 57/4 | note:G2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 57/4 → 15/1 | note:G2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 27/2 → 57/4 | note:A2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 57/4 → 15/1 | note:A2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 57/4 → 33/2 | gain:0.6 note:F5 velocity:0.918253320269 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 117/8 → 135/8 | gain:0.6 note:G3 velocity:0.571157105267 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 15/1 → 33/2 | note:G2 s:bass clip:1 gain:0.8 ]",
|
||||
@@ -7373,12 +7369,12 @@ exports[`renders tunes > tune: randomBells 1`] = `
|
||||
"[ (69/4 → 18/1) ⇝ 75/4 | gain:0.6 note:F3 velocity:0.508127085865 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 135/8 ⇜ (18/1 → 147/8) | gain:0.6 note:F5 velocity:0.945647025481 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 69/4 ⇜ (18/1 → 75/4) | gain:0.6 note:F3 velocity:0.508127085865 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 18/1 → 39/2 | note:F2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 18/1 → 39/2 | note:G2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 18/1 → 81/4 | gain:0.6 note:A3 velocity:0.608644555323 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 147/8 → 165/8 | gain:0.6 note:F3 velocity:0.506259439513 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 75/4 → 21/1 | gain:0.6 note:D4 velocity:0.671621939167 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 39/2 → 81/4 | note:F2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 81/4 → 21/1 | note:F2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 39/2 → 81/4 | note:G2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 81/4 → 21/1 | note:G2 s:bass clip:1 gain:0.8 ]",
|
||||
"[ 81/4 → 45/2 | gain:0.6 note:D4 velocity:0.704345900565 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 165/8 → 183/8 | gain:0.6 note:D5 velocity:0.887838857248 s:bell delay:0.2 delaytime:0.333333333333 delayfeedback:0.8 ]",
|
||||
"[ 21/1 → 45/2 | note:F2 s:bass clip:1 gain:0.8 ]",
|
||||
|
||||
@@ -99,7 +99,6 @@ const toneHelpersMocked = {
|
||||
'_spectrum',
|
||||
'markcss',
|
||||
'p',
|
||||
'dough',
|
||||
].forEach((mock) => {
|
||||
strudel.Pattern.prototype[mock] = function () {
|
||||
return this;
|
||||
@@ -175,7 +174,6 @@ evalScope(
|
||||
getDuration,
|
||||
setcps: id,
|
||||
setcpm: id,
|
||||
initDough: id,
|
||||
Clock: {}, // whatever
|
||||
},
|
||||
);
|
||||
|
||||
+2
-2
@@ -597,8 +597,8 @@
|
||||
],
|
||||
"/packages/superdough/dspworklet.mjs": [
|
||||
"dspWorklet",
|
||||
"rawdsp",
|
||||
"rawdspTrigger"
|
||||
"dough",
|
||||
"doughTrigger"
|
||||
],
|
||||
"/packages/superdough/index.mjs": [],
|
||||
"/packages/tonal/tonleiter.mjs": [
|
||||
|
||||
@@ -73,7 +73,6 @@ export default defineConfig({
|
||||
workbox: {
|
||||
maximumFileSizeToCacheInBytes: 4194304, // 4MB
|
||||
globPatterns: ['**/*.{js,css,html,ico,png,svg,json,wav,mp3,ogg,ttf,woff2,TTF,otf}'],
|
||||
globIgnores: ['img/**', '_astro/csound*.js'],
|
||||
runtimeCaching: [
|
||||
{
|
||||
urlPattern: ({ url }) =>
|
||||
@@ -89,7 +88,7 @@ export default defineConfig({
|
||||
cacheName: 'external-samples',
|
||||
expiration: {
|
||||
maxEntries: 5000,
|
||||
maxAgeSeconds: 60 * 60 * 24 * 30, // <== 30 days
|
||||
maxAgeSeconds: 60 * 60 * 24 * 30, // <== 14 days
|
||||
},
|
||||
cacheableResponse: {
|
||||
statuses: [0, 200],
|
||||
@@ -146,13 +145,4 @@ export default defineConfig({
|
||||
// external: ['fraction.js'], // https://github.com/infusion/Fraction.js/issues/51
|
||||
},
|
||||
},
|
||||
server: {
|
||||
// these are needed for dough, which uses shared memory
|
||||
// see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer#security_requirements
|
||||
// this is only for the dev server, so the server strudel runs on, also needs those
|
||||
headers: {
|
||||
'Cross-Origin-Opener-Policy': 'same-origin',
|
||||
'Cross-Origin-Embedder-Policy': 'credentialless',
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
@@ -41,7 +41,6 @@
|
||||
"@strudel/motion": "workspace:*",
|
||||
"@strudel/mqtt": "workspace:*",
|
||||
"@strudel/osc": "workspace:*",
|
||||
"@strudel/dough": "workspace:*",
|
||||
"@strudel/serial": "workspace:*",
|
||||
"@strudel/soundfonts": "workspace:*",
|
||||
"@strudel/tidal": "workspace:*",
|
||||
|
||||
@@ -24,7 +24,7 @@ const baseNoTrailing = BASE_URL.endsWith('/') ? BASE_URL.slice(0, -1) : BASE_URL
|
||||
|
||||
<base href={BASE_URL} />
|
||||
|
||||
<!-- Scrollable accessibility code helper -->
|
||||
<!-- Scrollable a11y code helper -->
|
||||
<script src={`${baseNoTrailing}/make-scrollable-code-focusable.js`} is:inline></script>
|
||||
|
||||
<script src="/src/pwa.ts"></script>
|
||||
|
||||
@@ -23,7 +23,7 @@ const baseNoTrailing = BASE_URL.endsWith('/') ? BASE_URL.slice(0, -1) : BASE_URL
|
||||
|
||||
<base href={BASE_URL} />
|
||||
|
||||
<!-- Scrollable accessibility code helper -->
|
||||
<!-- Scrollable a11y code helper -->
|
||||
<script src={`${baseNoTrailing}/make-scrollable-code-focusable.js`} is:inline></script>
|
||||
|
||||
<script src="/src/pwa.ts"></script>
|
||||
|
||||
@@ -16,7 +16,7 @@ const imageAlt = frontmatter.image?.alt ?? OPEN_GRAPH.image.alt;
|
||||
<!-- Page Metadata -->
|
||||
<link rel="canonical" href={canonicalUrl} />
|
||||
|
||||
<!-- og Tags -->
|
||||
<!-- OpenGraph Tags -->
|
||||
<meta property="og:title" content={formattedContentTitle} />
|
||||
<meta property="og:type" content="article" />
|
||||
<meta property="og:url" content={canonicalUrl} />
|
||||
|
||||
@@ -22,7 +22,7 @@ export function MiniRepl({
|
||||
tunes,
|
||||
hideHeader = false,
|
||||
canvasHeight = 100,
|
||||
onSchedule,
|
||||
onTrigger,
|
||||
punchcard,
|
||||
punchcardLabels = true,
|
||||
claviature,
|
||||
@@ -48,7 +48,7 @@ export function MiniRepl({
|
||||
|
||||
const editor = new StrudelMirror({
|
||||
id,
|
||||
onSchedule: webaudioOutput,
|
||||
defaultOutput: webaudioOutput,
|
||||
getTime: () => getAudioContext().currentTime,
|
||||
transpiler,
|
||||
autodraw,
|
||||
@@ -58,8 +58,8 @@ export function MiniRepl({
|
||||
drawTime,
|
||||
drawContext,
|
||||
editPattern: (pat, id) => {
|
||||
if (onSchedule) {
|
||||
pat = pat.onSchedule(onSchedule, false);
|
||||
if (onTrigger) {
|
||||
pat = pat.onTrigger(onTrigger, false);
|
||||
}
|
||||
if (claviature) {
|
||||
pat = pat.onPaint((ctx, time, haps, drawTime) => {
|
||||
|
||||
Vendored
-3
@@ -2,6 +2,3 @@
|
||||
/// <reference types="astro/client" />
|
||||
|
||||
declare module 'date-fns';
|
||||
declare module '@strudel/*';
|
||||
declare module 'dough-synth';
|
||||
declare module 'paho-mqtt';
|
||||
|
||||
@@ -36,7 +36,7 @@ const githubEditUrl = `${CONFIG.GITHUB_EDIT_URL}/${currentFile}`;
|
||||
<Header currentPage={currentPage} />
|
||||
</header>
|
||||
<main class="relative pt-16">
|
||||
<div class="h-full top-0 overflow-auto min-w-[300px] flex xl:justify-center pr-4 pl-4 md:pl-[300px] xl:pr-[300px]">
|
||||
<div class="h-full top-0 overflow-auto min-w-[300px] flex xl:justify-center pr-4 pl-4 md:pl-[300px] xl:pl-0">
|
||||
<aside title="Site Navigation" class="w-[300px] px-6 left-0 hidden md:block fixed h-full">
|
||||
<LeftSidebar currentPage={currentPage} />
|
||||
</aside>
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
import { getMetadata } from './metadata_parser';
|
||||
|
||||
export function getMyPatterns() {
|
||||
const my = import.meta.glob('../../my-patterns/**', { query: '?raw', eager: true });
|
||||
const my = import.meta.glob('../../my-patterns/**', { as: 'raw', eager: true });
|
||||
return Object.fromEntries(
|
||||
Object.entries(my)
|
||||
.filter(([name]) => name.endsWith('.txt'))
|
||||
|
||||
@@ -150,3 +150,5 @@ In the future, the integration could be improved by passing all patterned contro
|
||||
This could work by a unique [channel](https://kunstmusik.github.io/icsc2022-csound-web/tutorial2-interacting-with-csound/#step-4---writing-continuous-data-channels)
|
||||
for each value. Channels could be read [like this](https://github.com/csound/csound/blob/master/Android/CsoundForAndroid/CsoundAndroidExamples/src/main/res/raw/multitouch_xy.csd).
|
||||
Also, it might make sense to have a standard library of csound instruments for strudel's effects.
|
||||
|
||||
Now, let's dive into the [Functional JavaScript API](/functions/intro)
|
||||
|
||||
@@ -33,7 +33,7 @@ The signal chain in Strudel is as follows:
|
||||
- This is where the main (volume) ADSR happens
|
||||
- A lowpass filter (`lpf`)
|
||||
- A highpass filter (`hpf`)
|
||||
- A bandpass filter (`bpf`)
|
||||
- A bandpass filter (`bandpass`)
|
||||
- A vowel filter (`vowel`)
|
||||
- Sample rate reduction (`coarse`)
|
||||
- Bit crushing (`crush`)
|
||||
@@ -184,9 +184,9 @@ Each filter has 2 parameters:
|
||||
|
||||
Amplitude modulation changes the amplitude (gain) periodically over time.
|
||||
|
||||
## tremolo
|
||||
## am
|
||||
|
||||
<JsDoc client:idle name="tremolo" h={0} />
|
||||
<JsDoc client:idle name="am" h={0} />
|
||||
|
||||
## tremolosync
|
||||
|
||||
|
||||
@@ -18,6 +18,7 @@ These are the equivalents used by the Mini Notation:
|
||||
| `stack(x, y)` | `"x,y"` |
|
||||
| `stepcat([3,x],[2,y])` | `"x@3 y@2"` |
|
||||
| `polymeter([a, b, c], [x, y])` | `"{a b c, x y}"` |
|
||||
| `polymeterSteps(2, x, y, z)` | `"{x y z}%2"` |
|
||||
| `silence` | `"~"` |
|
||||
|
||||
## cat
|
||||
@@ -44,6 +45,10 @@ These are the equivalents used by the Mini Notation:
|
||||
|
||||
<JsDoc client:idle name="polymeter" h={0} />
|
||||
|
||||
## polymeterSteps
|
||||
|
||||
<JsDoc client:idle name="polymeterSteps" h={0} />
|
||||
|
||||
## silence
|
||||
|
||||
<JsDoc client:idle name="silence" h={0} />
|
||||
|
||||
@@ -52,15 +52,6 @@ There are multiple ways to load your sample collection. Some methods are good fo
|
||||
- Serve a folder of samples locally using the [strudel 'sampler' commandline tool](https://strudel.cc/learn/samples/#from-disk-via-strudelsampler). This can be most reliable method, but requires [nodejs](https://nodejs.org) to be installed.
|
||||
- Host your sound library online on the web and [load them from an URL](/learn/samples/#loading-custom-samples)
|
||||
|
||||
## Can I create a new project based on Strudel?
|
||||
|
||||
Strudel is free/open source software, and we are always happy to see people making use of it within the following terms:
|
||||
|
||||
- Please don't use 'strudel' in the name of your project (e.g. strudel2000, foo-strudel), so people don't assume it's official strudel project. (If you'd like it to be an official strudel project, please check in with the community, e.g. on the [discord chat](https://discord.com/invite/HGEdXmRkzT).)
|
||||
- Please respect our AGPL license, which e.g. requires you to share/link to the source code of strudel, any modifications you've made to it, and the source code for the rest of your project if it integrates with strudel. You are also required to maintain Strudel's copyright notices in the source code, and include Strudel's copyright notice in your user interface. This is an ad-hoc summary - please [refer to the license](https://codeberg.org/uzu/strudel/src/branch/main/LICENSE) for full details.
|
||||
|
||||
You are also encouraged to connect with [the community](https://discord.com/invite/HGEdXmRkzT) to understand our aims and values.
|
||||
|
||||
## Can I use Strudel with AI/LLM tools?
|
||||
|
||||
You are free to do what you like with Strudel, within the terms of the free/open source AGPLv3 license.
|
||||
@@ -346,11 +337,3 @@ s increase by one semitone, i.e. sharp, works for steps of scales, note names
|
||||
$: at the start of a line, defines a member of the stack. is the only stack name that should occur multiple names
|
||||
_ before a stack name: mutes the stack, i.e. hush(), for example _$: s("bd"), see above for a different usage.
|
||||
```
|
||||
|
||||
## What is a 'hap'?
|
||||
|
||||
A 'hap' is a name for a thing that happens, e.g. `note("c3 -")` playing a note and then stopping after a while. Haps have a start and an end. Every separate sound that is produced by strudel is a hap on its own.
|
||||
|
||||
We would have called it 'event' if this particular name wasn't used by JavaScript to describe things that happen on html pages, like clicking on a button or hovering over a line of text.
|
||||
|
||||
Since strudel is written in JavaScript, this confusion of having the same name for different things is avoided by calling events 'haps'.
|
||||
|
||||
@@ -45,7 +45,7 @@ Here, the LFO will modulate the low pass filter `.lpf`.
|
||||
|
||||
## Moving away from the default
|
||||
|
||||
The following sections explain how to pass parameters to `.lfo`. Similar to `._spectrum` above, almost all the configuration of `lfo` lives inside a json object, starting with `{` and ending with `}`.
|
||||
The following sections explain how pass parameters to `.lfo`. Similar to `._spectrum` above, almost all the configuration of `lfo` lives inside a json object, starting with `{` and ending with `}`.
|
||||
All the parameters (except `id`) are written as `key: value` inside and separated by `,`.
|
||||
|
||||
The reference refers to them as `config.key`, i.e. for the following one as `config.control` but you use them like below.
|
||||
|
||||
@@ -329,7 +329,7 @@ Sampler effects are functions that can be used to change the behaviour of sample
|
||||
|
||||
### begin
|
||||
|
||||
<JsDoc client:idle name="begin" h={0} />
|
||||
<JsDoc client:idle name="Pattern.begin" h={0} />
|
||||
|
||||
### end
|
||||
|
||||
|
||||
@@ -55,14 +55,6 @@ There is also `saw2`, `sine2`, `cosine2`, `tri2`, `square2` and `rand2` which ha
|
||||
|
||||
<JsDoc client:idle name="brandBy" h={0} />
|
||||
|
||||
## time
|
||||
|
||||
<JsDoc client:idle name="time" h={0} />
|
||||
|
||||
## creating your own signal
|
||||
|
||||
<JsDoc client:idle name="signal" h={0} />
|
||||
|
||||
## mouseX
|
||||
|
||||
<JsDoc client:idle name="mousex" h={0} />
|
||||
|
||||
@@ -12,17 +12,11 @@ import { JsDoc } from '../../docs/JsDoc';
|
||||
|
||||
These functions allow the use of scales other than your typical chromatic 12 based ones.
|
||||
|
||||
### xen(scaleOrRatios)
|
||||
|
||||
{/* TODO add explanation of EDO to documentation */}
|
||||
|
||||
<JsDoc client:idle name="Pattern.xen" h={0} />
|
||||
|
||||
### tune(scale)
|
||||
|
||||
{/* TODO (maybe): combine jsdoc things in tune.mjs with here */}
|
||||
|
||||
{/* <JsDoc client:idle name="tune" h={0} /> */}
|
||||
<JsDoc client:idle name="tune" h={0} />
|
||||
|
||||
Here's an example of how to configure a basic hexany scale:
|
||||
|
||||
@@ -116,3 +110,9 @@ You can also give tune a list of frequencies to use as the scale:
|
||||
523.2511306012
|
||||
]).mul(220).freq();`}
|
||||
/>
|
||||
|
||||
### xen(scaleOrRatios)
|
||||
|
||||
{/* TODO add explanation of EDO to documentation */}
|
||||
|
||||
<JsDoc client:idle name="Pattern.xen" h={0} />
|
||||
|
||||
@@ -186,9 +186,9 @@ These functions are more low level, probably not needed by the live coder.
|
||||
|
||||
# Other
|
||||
|
||||
## onSchedule
|
||||
## onTrigger
|
||||
|
||||
<JsDoc client:idle name="Pattern#onSchedule" h={0} />
|
||||
<JsDoc client:idle name="Pattern#onTrigger" h={0} />
|
||||
|
||||
## log
|
||||
|
||||
|
||||
@@ -8,7 +8,7 @@ import { JsDoc } from '../../docs/JsDoc';
|
||||
|
||||
# Patterns
|
||||
|
||||
Patterns are the essence of Uzu languages such as Strudel and Tidal. Its patterns are abstract entities that represent flows of time as functions, adapting a technique called pure functional reactive programming. Taking a time span as its input, a Pattern can output a set of events that happen within that time span. It depends on the structure of the Pattern how the events are located in time.
|
||||
Patterns are the essence of Tidal. Its patterns are abstract entities that represent flows of time as functions, adapting a technique called pure functional reactive programming. Taking a time span as its input, a Pattern can output a set of events that happen within that time span. It depends on the structure of the Pattern how the events are located in time.
|
||||
From now on, this process of generating events from a time span will be called **querying**.
|
||||
Example:
|
||||
|
||||
|
||||
@@ -17,7 +17,7 @@ Besides a UI for playback control and meta information, the main part of the REP
|
||||
|
||||
1. The user writes and updates code. Each update transpiles and evaluates it to create a `Pattern` instance
|
||||
2. While the REPL is running, the `Scheduler` queries the active `Pattern` by a regular interval, generating `Events` (also known as `Haps` in Strudel) for the next time span.
|
||||
3. For each scheduling tick, all generated `Events` are triggered by calling their `onSchedule` method, which is set by the output.
|
||||
3. For each scheduling tick, all generated `Events` are triggered by calling their `onTrigger` method, which is set by the output.
|
||||
|
||||
<img src="https://codeberg.org/uzu/strudel/raw/branch/talk/talk/public/strudelflow.png" width="600" />
|
||||
|
||||
@@ -134,7 +134,10 @@ let minLatency = 0.1; // min time before a hap should trigger
|
||||
setInterval(() => {
|
||||
const haps = pattern.queryArc(time, time + interval);
|
||||
time += interval; // increment time
|
||||
haps.forEach((hap) => onSchedule(hap, hap.whole.begin + minLatency));
|
||||
haps.forEach((hap) => {
|
||||
const deadline = hap.whole.begin - time + minLatency;
|
||||
onTrigger(hap, deadline, duration);
|
||||
});
|
||||
}, interval * 1000); // query each "interval" seconds
|
||||
```
|
||||
|
||||
@@ -178,19 +181,20 @@ This example creates the custom control parameters `x` and `y` which are then us
|
||||
|
||||
### Outputs
|
||||
|
||||
Now that we know how the value of an hap is manipulated using control parameters, we can look at how outputs can use that value to generate anything. The scheduler above was calling the `onSchedule` function which is used to implement the output. A very simple version of the web audio output could look like this:
|
||||
Now that we know how the value of an event is manipulated using control parameters, we can look at how outputs can use that value to generate anything. The scheduler above was calling the `onTrigger` function which is used to implement the output. A very simple version of the web audio output could look like this:
|
||||
|
||||
```js
|
||||
function onSchedule(hap, time, cps) {
|
||||
function onTrigger(hap, deadline, duration) {
|
||||
const { note } = hap.value;
|
||||
const time = getAudioContext().currentTime + deadline;
|
||||
const o = getAudioContext().createOscillator();
|
||||
o.frequency.value = getFreq(note);
|
||||
o.start(time);
|
||||
o.stop(time + hap.duration / cps);
|
||||
o.stop(time + event.duration);
|
||||
o.connect(getAudioContext().destination);
|
||||
}
|
||||
```
|
||||
|
||||
The above example will create an `OscillatorNode` for each hap, where the frequency is controlled by the `note` param. In essence, this is how the WebAudio API output of Strudel works, only with many more parameters to control synths, samples and effects.
|
||||
The above example will create an `OscillatorNode` for each event, where the frequency is controlled by the `note` param. In essence, this is how the WebAudio API output of Strudel works, only with many more parameters to control synths, samples and effects.
|
||||
|
||||
I want to help, how do I contribute to the [Docs](/technical-manual/docs)?
|
||||
|
||||
@@ -287,10 +287,7 @@ The modes are:
|
||||
- `below`: the top note of the voicing is lower than or equal to the anchor (default)
|
||||
- `above`: the bottom note of the voicing is higher than or equal to the anchor
|
||||
- `duck`: the top note of the voicing is lower than the anchor
|
||||
- `root`: the bottom note of the voicing is always the lowest root note higher than or equal to the anchor
|
||||
|
||||
- `oldabove` : old (buggy) behavior of above, kept for legacy reasons
|
||||
- `oldroot` : old (buggy) behavior of root, kept for legacy reasons
|
||||
- `root`: the bottom note of the voicing is always the root note closest to the anchor
|
||||
|
||||
The `anchor` can also be set from within the `mode` function:
|
||||
|
||||
|
||||
@@ -628,7 +628,7 @@ export const debugAudiograph = async (argOptions = {}) => {
|
||||
|
||||
/*global all*/
|
||||
all((pat) =>
|
||||
pat.onSchedule(async (hap, t, cps) => {
|
||||
pat.onTrigger(async (hap, duration, cps, t) => {
|
||||
hap_count++;
|
||||
const key = Object.entries(hap.value)
|
||||
.map((param) => param.join('/'))
|
||||
@@ -643,7 +643,7 @@ export const debugAudiograph = async (argOptions = {}) => {
|
||||
return;
|
||||
}
|
||||
|
||||
await webaudioOutput(hap, t, cps);
|
||||
await webaudioOutput(hap, t, hap.duration / cps, cps, t);
|
||||
|
||||
if (hapsBatch && hap_count % hapsBatch === 0) drawDiagram();
|
||||
}),
|
||||
|
||||
@@ -214,12 +214,7 @@ export const Reference = memo(function Reference() {
|
||||
</p>
|
||||
)}
|
||||
|
||||
<p
|
||||
dangerouslySetInnerHTML={{
|
||||
// If we have an external url make sure it opens in another tab to not interrupt the player
|
||||
__html: entry.description.replaceAll(/<a href="https:\/\//g, `<a target="_blank" href="https://`),
|
||||
}}
|
||||
></p>
|
||||
<p dangerouslySetInnerHTML={{ __html: entry.description }}></p>
|
||||
<ul>
|
||||
{entry.params?.map(({ name, type, description }, i) => (
|
||||
<li key={i}>
|
||||
|
||||
@@ -36,9 +36,8 @@ export function WelcomeTab({ context }) {
|
||||
<a href="https://tidalcycles.org/" target="_blank">
|
||||
tidalcycles
|
||||
</a>
|
||||
, which is a popular live coding language for music, written in Haskell. Strudel is free/open source software,
|
||||
with copyright owned by its [contributors](https://codeberg.org/uzu/strudel/activity/contributors). You can
|
||||
redistribute and/or modify it under the terms of the{' '}
|
||||
, which is a popular live coding language for music, written in Haskell. Strudel is free/open source software:
|
||||
you can redistribute and/or modify it under the terms of the{' '}
|
||||
<a href="https://codeberg.org/uzu/strudel/src/branch/main/LICENSE" target="_blank">
|
||||
GNU Affero General Public License
|
||||
</a>
|
||||
|
||||
@@ -68,7 +68,7 @@ const initialCode = `// LOADING`;
|
||||
export function useReplContext() {
|
||||
const { isSyncEnabled, audioEngineTarget, prebakeScript, includePrebakeScriptInShare } = useSettings();
|
||||
const shouldUseWebaudio = audioEngineTarget !== audioEngineTargets.osc;
|
||||
const onSchedule = shouldUseWebaudio ? webaudioOutput : superdirtOutput;
|
||||
const defaultOutput = shouldUseWebaudio ? webaudioOutput : superdirtOutput;
|
||||
const getTime = shouldUseWebaudio ? getAudioContextCurrentTime : getPerformanceTimeSeconds;
|
||||
const init = useCallback(() => {
|
||||
setActivePattern(getViewingPatternData().id);
|
||||
@@ -76,7 +76,7 @@ export function useReplContext() {
|
||||
const drawContext = getDrawContext();
|
||||
const editor = new StrudelMirror({
|
||||
sync: isSyncEnabled,
|
||||
onSchedule,
|
||||
defaultOutput,
|
||||
getTime,
|
||||
setInterval,
|
||||
clearInterval,
|
||||
|
||||
@@ -1,15 +1,12 @@
|
||||
import * as strudelCore from '@strudel/core';
|
||||
import * as strudelWebaudio from '@strudel/webaudio';
|
||||
import { code2hash, errorLogger, evalScope, hash2code, logger } from '@strudel/core';
|
||||
import { settingPatterns } from '../settings.mjs';
|
||||
import { getMetadata } from '../metadata_parser.js';
|
||||
import { setVersionDefaults } from '@strudel/webaudio';
|
||||
import { getMetadata } from '../metadata_parser';
|
||||
import { isTauri } from '../tauri.mjs';
|
||||
import './Repl.css';
|
||||
import { createClient } from '@supabase/supabase-js';
|
||||
import { writeText } from '@tauri-apps/plugin-clipboard-manager';
|
||||
import { $featuredPatterns } from '@src/user_pattern_utils.mjs';
|
||||
|
||||
const { setVersionDefaults } = strudelWebaudio;
|
||||
const { code2hash, errorLogger, evalScope, hash2code, logger } = strudelCore;
|
||||
import { $featuredPatterns /* , loadDBPatterns */ } from '@src/user_pattern_utils.mjs';
|
||||
|
||||
// Create a single supabase client for interacting with your database
|
||||
export const supabase = createClient(
|
||||
@@ -71,13 +68,13 @@ export async function getRandomTune() {
|
||||
|
||||
export function loadModules() {
|
||||
let modules = [
|
||||
strudelCore,
|
||||
import('@strudel/core'),
|
||||
import('@strudel/draw'),
|
||||
import('@strudel/edo'),
|
||||
import('@strudel/tonal'),
|
||||
import('@strudel/mini'),
|
||||
import('@strudel/xen'),
|
||||
strudelWebaudio,
|
||||
import('@strudel/webaudio'),
|
||||
import('@strudel/codemirror'),
|
||||
import('@strudel/hydra'),
|
||||
import('@strudel/serial'),
|
||||
@@ -88,7 +85,6 @@ export function loadModules() {
|
||||
import('@strudel/motion'),
|
||||
import('@strudel/mqtt'),
|
||||
import('@strudel/mondo'),
|
||||
import('@strudel/dough'),
|
||||
];
|
||||
if (isTauri()) {
|
||||
modules = modules.concat([
|
||||
|
||||
@@ -138,7 +138,7 @@ export const setIsZen = (active) => settingsMap.setKey('isZen', !!active);
|
||||
|
||||
const patternSetting = (key) =>
|
||||
register(key, (value, pat) =>
|
||||
pat.onSchedule(() => {
|
||||
pat.onTrigger(() => {
|
||||
value = Array.isArray(value) ? value.join(' ') : value;
|
||||
if (value !== settingsMap.get()[key]) {
|
||||
settingsMap.setKey(key, value);
|
||||
|
||||
Reference in New Issue
Block a user