Something went wrong. Try again.
Monorepo for Aesthetic.Computer aesthetic.computer
Something went wrong. Try again.
35 kB · 901 lines
JavaScript
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902import { createSeededRandom, hashString } from "./runtime.mjs";
const GLOBAL_GRID_X = 4;const GLOBAL_GRID_Y = 4;const GLOBAL_FEATURE_COUNT = 13 + GLOBAL_GRID_X * GLOBAL_GRID_Y;const STATE_LATENT_SIZE = 8;const CELL_COUNT = 64;const TILE_GRID_X = 8;const TILE_GRID_Y = 8;const TILE_FEATURE_COUNT = 12;const LATENT_FIELD_CHANNELS = 12;const OUTPUT_SIZE = 40;const ADDITIVE_PARTIALS = 6;const FORMANT_COUNT = 3;const EXPERT_NAMES = ["tonal", "vocal", "table", "living"];const TAU = Math.PI * 2;
export const DECODER_NAMES = [...EXPERT_NAMES];
const SOUND_STYLES = { default: { latentBlend: 0.24, fieldBlend: 0.68, fieldMemory: 0.64, byteMixScale: 0.9, petriMixScale: 0.82, tonalMixScale: 0.98, vocalMixScale: 0.96, tableMixScale: 1.08, livingMixScale: 0.78, byteSoftness: 0.18, byteLowpass: 0.66, outputSmoothing: 0.58, gainScale: 0.92, panScale: 1.0, exciteScale: 1.0, couplingScale: 1.0, growScale: 1.0, diffuseScale: 1.0, sparkleScale: 1.0, byteHarmonicsScale: 1.0, formantWarmth: 1.0, tableWarpScale: 1.0, }, soft: { latentBlend: 0.18, fieldBlend: 0.6, fieldMemory: 0.74, byteMixScale: 0.34, petriMixScale: 0.74, tonalMixScale: 0.88, vocalMixScale: 1.12, tableMixScale: 0.82, livingMixScale: 0.28, byteSoftness: 0.78, byteLowpass: 0.9, outputSmoothing: 0.88, gainScale: 0.82, panScale: 0.68, exciteScale: 0.54, couplingScale: 0.68, growScale: 0.76, diffuseScale: 1.18, sparkleScale: 0.72, byteHarmonicsScale: 0.58, formantWarmth: 1.18, tableWarpScale: 0.74, },};
function clamp(value, low, high) { return Math.max(low, Math.min(high, value));}
function lerp(a, b, t) { return a + (b - a) * t;}
function mapSigned(value, low, high) { return low + ((value + 1) * 0.5) * (high - low);}
function tanh(value) { return Math.tanh(value);}
function normalize01(value) { return clamp(value, 0, 1) * 2 - 1;}
function wrap01(value) { const wrapped = value % 1; return wrapped < 0 ? wrapped + 1 : wrapped;}
function buildNetwork(seed, inputSize, hiddenSizes, outputSize) { const prng = createSeededRandom(seed); const sizes = [inputSize, ...hiddenSizes, outputSize]; const layers = [];
for (let layerIndex = 0; layerIndex < sizes.length - 1; layerIndex += 1) { const inSize = sizes[layerIndex]; const outSize = sizes[layerIndex + 1]; const scale = 1 / Math.sqrt(inSize); const weights = new Float32Array(inSize * outSize); const biases = new Float32Array(outSize);
for (let i = 0; i < weights.length; i += 1) { weights[i] = (prng() * 2 - 1) * scale; }
for (let i = 0; i < biases.length; i += 1) { biases[i] = (prng() * 2 - 1) * scale; }
layers.push({ inSize, outSize, weights, biases }); }
return { layers };}
function forwardNetwork(network, input) { let activations = input;
for (let layerIndex = 0; layerIndex < network.layers.length; layerIndex += 1) { const layer = network.layers[layerIndex]; const next = new Float32Array(layer.outSize); for (let out = 0; out < layer.outSize; out += 1) { let sum = layer.biases[out]; const weightOffset = out * layer.inSize; for (let i = 0; i < layer.inSize; i += 1) { sum += layer.weights[weightOffset + i] * activations[i]; } next[out] = tanh(sum); } activations = next; }
return activations;}
function colorPolar(r, g, b) { const hueAngle = Math.atan2(Math.sqrt(3) * (g - b), 2 * r - g - b); const max = Math.max(r, g, b); const min = Math.min(r, g, b); return { hueSin: Math.sin(hueAngle), hueCos: Math.cos(hueAngle), saturation: max - min, value: max, };}
function extractFramebufferFeatures(rgba, width, height) { const totalPixels = Math.max(1, width * height); const invW = width > 1 ? 1 / (width - 1) : 0; const invH = height > 1 ? 1 / (height - 1) : 0; const prevRow = new Float32Array(width); const gridSums = new Float32Array(GLOBAL_GRID_X * GLOBAL_GRID_Y); const gridCounts = new Float32Array(GLOBAL_GRID_X * GLOBAL_GRID_Y);
let rSum = 0; let gSum = 0; let bSum = 0; let lumSum = 0; let lumSqSum = 0; let edgeX = 0; let edgeY = 0; let centroidX = 0; let centroidY = 0; let diagMain = 0; let diagCross = 0;
for (let y = 0; y < height; y += 1) { let leftLum = 0; for (let x = 0; x < width; x += 1) { const offset = (y * width + x) * 4; const r = rgba[offset] / 255; const g = rgba[offset + 1] / 255; const b = rgba[offset + 2] / 255; const lum = r * 0.299 + g * 0.587 + b * 0.114;
rSum += r; gSum += g; bSum += b; lumSum += lum; lumSqSum += lum * lum; centroidX += x * invW * lum; centroidY += y * invH * lum;
if (x > 0) edgeX += Math.abs(lum - leftLum); if (y > 0) edgeY += Math.abs(lum - prevRow[x]); leftLum = lum; prevRow[x] = lum;
if (x <= y * (width / Math.max(1, height))) diagMain += lum; else diagCross += lum;
const cellX = Math.min(GLOBAL_GRID_X - 1, Math.floor((x / Math.max(1, width)) * GLOBAL_GRID_X)); const cellY = Math.min(GLOBAL_GRID_Y - 1, Math.floor((y / Math.max(1, height)) * GLOBAL_GRID_Y)); const cellIndex = cellY * GLOBAL_GRID_X + cellX; gridSums[cellIndex] += lum; gridCounts[cellIndex] += 1; } }
const meanR = rSum / totalPixels; const meanG = gSum / totalPixels; const meanB = bSum / totalPixels; const meanLum = lumSum / totalPixels; const varianceLum = Math.max(0, lumSqSum / totalPixels - meanLum * meanLum); const edgeNormX = edgeX / totalPixels; const edgeNormY = edgeY / totalPixels; const centroidNormX = lumSum > 1e-6 ? centroidX / lumSum : 0.5; const centroidNormY = lumSum > 1e-6 ? centroidY / lumSum : 0.5; const colorSpread = (Math.abs(meanR - meanG) + Math.abs(meanG - meanB) + Math.abs(meanB - meanR)) / 3; const diagonalBias = (diagMain - diagCross) / Math.max(1e-6, diagMain + diagCross);
const features = new Float32Array(GLOBAL_FEATURE_COUNT); features[0] = normalize01(meanLum); features[1] = normalize01(meanR); features[2] = normalize01(meanG); features[3] = normalize01(meanB); features[4] = clamp(varianceLum * 10 - 1, -1, 1); features[5] = clamp(edgeNormX * 5 - 1, -1, 1); features[6] = clamp(edgeNormY * 5 - 1, -1, 1); features[7] = centroidNormX * 2 - 1; features[8] = centroidNormY * 2 - 1; features[9] = clamp(meanR - meanG, -1, 1); features[10] = clamp(meanG - meanB, -1, 1); features[11] = clamp(colorSpread * 4 - 1, -1, 1); features[12] = clamp(diagonalBias, -1, 1);
for (let i = 0; i < gridSums.length; i += 1) { const average = gridSums[i] / Math.max(1, gridCounts[i]); features[13 + i] = average * 2 - 1; }
return features;}
function extractTileFeatures(rgba, width, height, tileX, tileY) { const startX = Math.floor((tileX * width) / TILE_GRID_X); const endX = Math.max(startX + 1, Math.floor(((tileX + 1) * width) / TILE_GRID_X)); const startY = Math.floor((tileY * height) / TILE_GRID_Y); const endY = Math.max(startY + 1, Math.floor(((tileY + 1) * height) / TILE_GRID_Y)); const tileWidth = Math.max(1, endX - startX); const tileHeight = Math.max(1, endY - startY); const totalPixels = tileWidth * tileHeight; const prevRow = new Float32Array(tileWidth);
let rSum = 0; let gSum = 0; let bSum = 0; let lumSum = 0; let lumSqSum = 0; let edgeX = 0; let edgeY = 0; let hueSinSum = 0; let hueCosSum = 0; let satSum = 0;
for (let y = startY; y < endY; y += 1) { let leftLum = 0; for (let x = startX; x < endX; x += 1) { const localX = x - startX; const offset = (y * width + x) * 4; const r = rgba[offset] / 255; const g = rgba[offset + 1] / 255; const b = rgba[offset + 2] / 255; const lum = r * 0.299 + g * 0.587 + b * 0.114; const polar = colorPolar(r, g, b);
rSum += r; gSum += g; bSum += b; lumSum += lum; lumSqSum += lum * lum; hueSinSum += polar.hueSin; hueCosSum += polar.hueCos; satSum += polar.saturation;
if (x > startX) edgeX += Math.abs(lum - leftLum); if (y > startY) edgeY += Math.abs(lum - prevRow[localX]); leftLum = lum; prevRow[localX] = lum; } }
const meanR = rSum / totalPixels; const meanG = gSum / totalPixels; const meanB = bSum / totalPixels; const meanLum = lumSum / totalPixels; const varianceLum = Math.max(0, lumSqSum / totalPixels - meanLum * meanLum); const features = new Float32Array(TILE_FEATURE_COUNT);
features[0] = normalize01(meanLum); features[1] = normalize01(meanR); features[2] = normalize01(meanG); features[3] = normalize01(meanB); features[4] = clamp(varianceLum * 10 - 1, -1, 1); features[5] = clamp(edgeX / totalPixels * 6 - 1, -1, 1); features[6] = clamp(edgeY / totalPixels * 6 - 1, -1, 1); features[7] = clamp(hueSinSum / totalPixels, -1, 1); features[8] = clamp(hueCosSum / totalPixels, -1, 1); features[9] = clamp(satSum / totalPixels * 2 - 1, -1, 1); features[10] = tileX / Math.max(1, TILE_GRID_X - 1) * 2 - 1; features[11] = tileY / Math.max(1, TILE_GRID_Y - 1) * 2 - 1;
return features;}
function buildPcmField(rgba, width, height) { const totalPixels = Math.max(1, width * height); const field = new Float32Array(totalPixels * 3); let energy = 0;
for (let pixelIndex = 0; pixelIndex < totalPixels; pixelIndex += 1) { const rgbaOffset = pixelIndex * 4; const writeOffset = pixelIndex * 3; const r = rgba[rgbaOffset] / 127.5 - 1; const g = rgba[rgbaOffset + 1] / 127.5 - 1; const b = rgba[rgbaOffset + 2] / 127.5 - 1; field[writeOffset] = r; field[writeOffset + 1] = g; field[writeOffset + 2] = b; energy += Math.abs(r) + Math.abs(g) + Math.abs(b); }
return { field, energy: energy / field.length, };}
function samplePcmField(field, phase) { const scaled = wrap01(phase) * field.length; const index = Math.floor(scaled); const nextIndex = (index + 1) % field.length; const frac = scaled - index; return lerp(field[index], field[nextIndex], frac);}
function encodeLatentField(rgba, width, height, previousField, globalLatent, encoderNetwork, style) { const input = new Float32Array(TILE_FEATURE_COUNT + STATE_LATENT_SIZE + LATENT_FIELD_CHANNELS); const nextField = new Float32Array(previousField.length); const summary = new Float32Array(LATENT_FIELD_CHANNELS); let flux = 0; let energy = 0;
for (let tileY = 0; tileY < TILE_GRID_Y; tileY += 1) { for (let tileX = 0; tileX < TILE_GRID_X; tileX += 1) { const tileFeatures = extractTileFeatures(rgba, width, height, tileX, tileY); const tileIndex = tileY * TILE_GRID_X + tileX; const latentOffset = tileIndex * LATENT_FIELD_CHANNELS; const previousLatent = previousField.subarray(latentOffset, latentOffset + LATENT_FIELD_CHANNELS); input.set(tileFeatures, 0); input.set(globalLatent, TILE_FEATURE_COUNT); input.set(previousLatent, TILE_FEATURE_COUNT + STATE_LATENT_SIZE); const encoded = forwardNetwork(encoderNetwork, input);
for (let channel = 0; channel < LATENT_FIELD_CHANNELS; channel += 1) { const directFeature = tileFeatures[channel % TILE_FEATURE_COUNT]; const encodedValue = lerp(directFeature, encoded[channel], style.fieldBlend); const nextValue = clamp(previousLatent[channel] * style.fieldMemory + encodedValue * (1 - style.fieldMemory), -1, 1); nextField[latentOffset + channel] = nextValue; summary[channel] += nextValue; flux += Math.abs(nextValue - previousLatent[channel]); energy += Math.abs(nextValue); } } }
const divisor = TILE_GRID_X * TILE_GRID_Y; for (let channel = 0; channel < summary.length; channel += 1) { summary[channel] /= divisor; }
return { field: nextField, summary, flux: flux / nextField.length, energy: energy / nextField.length, };}
function sampleLatentField(field, x, y, out) { const fx = wrap01(x) * TILE_GRID_X; const fy = wrap01(y) * TILE_GRID_Y; const x0 = Math.floor(fx) % TILE_GRID_X; const y0 = Math.floor(fy) % TILE_GRID_Y; const x1 = (x0 + 1) % TILE_GRID_X; const y1 = (y0 + 1) % TILE_GRID_Y; const tx = fx - Math.floor(fx); const ty = fy - Math.floor(fy);
const index00 = (y0 * TILE_GRID_X + x0) * LATENT_FIELD_CHANNELS; const index10 = (y0 * TILE_GRID_X + x1) * LATENT_FIELD_CHANNELS; const index01 = (y1 * TILE_GRID_X + x0) * LATENT_FIELD_CHANNELS; const index11 = (y1 * TILE_GRID_X + x1) * LATENT_FIELD_CHANNELS;
for (let channel = 0; channel < LATENT_FIELD_CHANNELS; channel += 1) { const a = lerp(field[index00 + channel], field[index10 + channel], tx); const b = lerp(field[index01 + channel], field[index11 + channel], tx); out[channel] = lerp(a, b, ty); }
return out;}
function interpretRules(output, features, fieldSummary) { const brightness = (features[0] + 1) * 0.5; const edge = ((features[5] + 1) * 0.5 + (features[6] + 1) * 0.5) * 0.5; const spread = (features[11] + 1) * 0.5; const fieldColor = (Math.abs(fieldSummary[1]) + Math.abs(fieldSummary[2]) + Math.abs(fieldSummary[3])) / 3; const fieldMotion = (Math.abs(fieldSummary[4]) + Math.abs(fieldSummary[5])) * 0.5;
return { grow: mapSigned(output[8], 0.02, 0.2) * (0.7 + brightness * 0.6), diffuse: mapSigned(output[9], 0.01, 0.26) * (0.7 + edge * 0.5), decay: mapSigned(output[10], 0.004, 0.07), excite: mapSigned(output[11], 0.04, 0.92), coupling: mapSigned(output[12], 0.08, 0.88), strideA: Math.max(1, Math.round(mapSigned(output[13], 1, 19))), strideB: Math.max(1, Math.round(mapSigned(output[14], 3, 29))), shiftA: Math.max(1, Math.round(mapSigned(output[15], 2, 9))), shiftB: Math.max(1, Math.round(mapSigned(output[16], 3, 13))), shiftC: Math.max(1, Math.round(mapSigned(output[17], 4, 17))), mulA: Math.max(1, Math.round(mapSigned(output[18], 3, 61))), mulB: Math.max(1, Math.round(mapSigned(output[19], 5, 83))), mask: Math.max(31, Math.round(mapSigned(output[20], 31, 255))), byteMix: mapSigned(output[21], 0.08, 0.8), petriMix: mapSigned(output[22], 0.06, 0.76), panSkew: clamp(output[23] + features[7] * 0.25, -1, 1), sparkle: clamp(spread * 0.55 + brightness * 0.25 + fieldColor * 0.2, 0, 1), tonalMix: mapSigned(output[24], 0.16, 0.96), vocalMix: mapSigned(output[25], 0.1, 0.92), tableMix: mapSigned(output[26], 0.22, 1.05), livingMix: mapSigned(output[27], 0.08, 0.88), scanRateX: mapSigned(output[28], -0.42, 0.42) * (0.45 + edge * 0.5), scanRateY: mapSigned(output[29], -0.42, 0.42) * (0.45 + spread * 0.5), scanWarp: mapSigned(output[30], 0.08, 2.4), scanOrbit: mapSigned(output[31], 0.02, 0.34), basePitch: mapSigned(output[32], 42, 420) * (0.72 + brightness * 0.42 + fieldColor * 0.12), pitchSpread: mapSigned(output[33], 0.2, 2.8), breath: mapSigned(output[34], 0.04, 0.88), formantShift: mapSigned(output[35], 0.78, 1.44), tableRate: mapSigned(output[36], 0.24, 2.8), tableWarp: mapSigned(output[37], 0.08, 3.2), latentDrift: mapSigned(output[38], 0.02, 0.28) * (0.6 + fieldMotion * 0.5), stereoDrift: clamp(output[39], -1, 1), };}
function seedPetriDish(cells, features, latent) { for (let i = 0; i < cells.length; i += 1) { const feature = features[i % features.length]; const memory = latent[i % latent.length]; cells[i] = clamp(cells[i] * 0.7 + feature * 0.2 + memory * 0.1, -1, 1); }}
function evolvePetriDish(state, features, rules, sampleIndex) { const current = state.cells; const next = state.nextCells; const latent = state.latent; const featureOffset = sampleIndex % features.length;
for (let i = 0; i < current.length; i += 1) { const left = current[(i + current.length - 1) % current.length]; const center = current[i]; const right = current[(i + 1) % current.length]; const feature = features[(featureOffset + i * 3) % features.length]; const memory = latent[i % latent.length]; const reagent = feature * rules.excite + memory * rules.coupling; const growth = tanh(left * 0.9 + center * (0.4 + rules.sparkle) + right * 0.9 + reagent); const diffusion = (left + right - 2 * center) * rules.diffuse; next[i] = clamp(center * (1 - rules.decay) + growth * rules.grow + diffusion, -1, 1); }
state.cells = next; state.nextCells = current;}
function bytebeatSample(t, rules, petriByteA, petriByteB) { return ( (((t * rules.mulA) & ((t >> rules.shiftA) | petriByteA)) ^ ((t * rules.mulB) & (t >> rules.shiftB)) ^ ((t + petriByteB) >> rules.shiftC)) & rules.mask ) & 255;}
function blendRules(a, b, mix, style) { return { grow: lerp(a.grow, b.grow, mix) * style.growScale, diffuse: lerp(a.diffuse, b.diffuse, mix) * style.diffuseScale, decay: lerp(a.decay, b.decay, mix), excite: lerp(a.excite, b.excite, mix) * style.exciteScale, coupling: lerp(a.coupling, b.coupling, mix) * style.couplingScale, strideA: Math.round(lerp(a.strideA, b.strideA, mix)), strideB: Math.round(lerp(a.strideB, b.strideB, mix)), shiftA: Math.round(lerp(a.shiftA, b.shiftA, mix)), shiftB: Math.round(lerp(a.shiftB, b.shiftB, mix)), shiftC: Math.round(lerp(a.shiftC, b.shiftC, mix)), mulA: Math.round(lerp(a.mulA, b.mulA, mix)), mulB: Math.round(lerp(a.mulB, b.mulB, mix)), mask: Math.round(lerp(a.mask, b.mask, mix)), byteMix: clamp(lerp(a.byteMix, b.byteMix, mix), 0.05, 1.2), petriMix: clamp(lerp(a.petriMix, b.petriMix, mix), 0.05, 1.25), panSkew: lerp(a.panSkew, b.panSkew, mix), sparkle: lerp(a.sparkle, b.sparkle, mix), tonalMix: clamp(lerp(a.tonalMix, b.tonalMix, mix), 0.02, 1.2), vocalMix: clamp(lerp(a.vocalMix, b.vocalMix, mix), 0.02, 1.2), tableMix: clamp(lerp(a.tableMix, b.tableMix, mix), 0.02, 1.2), livingMix: clamp(lerp(a.livingMix, b.livingMix, mix), 0.02, 1.2), scanRateX: lerp(a.scanRateX, b.scanRateX, mix), scanRateY: lerp(a.scanRateY, b.scanRateY, mix), scanWarp: lerp(a.scanWarp, b.scanWarp, mix), scanOrbit: lerp(a.scanOrbit, b.scanOrbit, mix), basePitch: lerp(a.basePitch, b.basePitch, mix), pitchSpread: lerp(a.pitchSpread, b.pitchSpread, mix), breath: lerp(a.breath, b.breath, mix), formantShift: lerp(a.formantShift, b.formantShift, mix), tableRate: lerp(a.tableRate, b.tableRate, mix), tableWarp: lerp(a.tableWarp, b.tableWarp, mix), latentDrift: lerp(a.latentDrift, b.latentDrift, mix), stereoDrift: lerp(a.stereoDrift, b.stereoDrift, mix), };}
function normalizeWeights(values) { const output = new Float32Array(values.length); let sum = 0;
for (let i = 0; i < values.length; i += 1) { const value = Math.max(0.0001, values[i]); output[i] = value; sum += value; }
for (let i = 0; i < output.length; i += 1) { output[i] /= sum; }
return output;}
function deriveExpertWeights(rules, latentVec, style) { return normalizeWeights([ rules.tonalMix * style.tonalMixScale * (0.52 + (latentVec[0] + 1) * 0.2 + Math.abs(latentVec[6]) * 0.12), rules.vocalMix * style.vocalMixScale * (0.48 + (latentVec[1] + 1) * 0.18 + rules.breath * 0.2), rules.tableMix * style.tableMixScale * (0.55 + (latentVec[2] + 1) * 0.18 + Math.abs(latentVec[7]) * 0.14), rules.livingMix * style.livingMixScale * (0.42 + (latentVec[3] + 1) * 0.18 + rules.sparkle * 0.2), ]);}
function stepAdditive(channelState, latentVec, rules, sampleRate, stereoOffset) { const basePitch = clamp( rules.basePitch * Math.pow(2, latentVec[0] * rules.pitchSpread * 0.3) * (1 + stereoOffset * 0.015), 24, sampleRate * 0.45, );
let sum = 0; let ampSum = 0;
for (let partial = 0; partial < ADDITIVE_PARTIALS; partial += 1) { const ratio = 1 + partial * (0.78 + (latentVec[(partial + 2) % latentVec.length] + 1) * 0.22); const detune = 1 + stereoOffset * 0.012 * (partial + 1) + latentVec[(partial + 5) % latentVec.length] * 0.004; const frequency = clamp(basePitch * ratio * detune, 24, sampleRate * 0.45); channelState.phases[partial] = (channelState.phases[partial] + TAU * frequency / sampleRate) % TAU; const amplitude = (0.28 + (latentVec[(partial + 7) % latentVec.length] + 1) * 0.18) / (partial + 1); sum += Math.sin(channelState.phases[partial]) * amplitude; ampSum += amplitude; }
return ampSum > 0 ? sum / ampSum : 0;}
function resonatorStep(frequency, bandwidth, input, state, offset, sampleRate) { const clampedFrequency = clamp(frequency, 40, sampleRate * 0.45); const radius = clamp(Math.exp(-Math.PI * bandwidth / sampleRate), 0.7, 0.9995); const coefficient = 2 * radius * Math.cos(TAU * clampedFrequency / sampleRate); const output = input + coefficient * state[offset] - radius * radius * state[offset + 1]; state[offset + 1] = state[offset]; state[offset] = output; return output;}
function stepVocal(channelState, latentVec, rules, sampleRate, noiseValue, style, stereoOffset) { const basePitch = clamp( rules.basePitch * (0.45 + (latentVec[4] + 1) * 0.18) * (1 + stereoOffset * 0.02), 55, 720, ); channelState.phase = (channelState.phase + TAU * basePitch / sampleRate) % TAU;
const voiced = Math.sin(channelState.phase) * 0.78 + Math.sin(channelState.phase * 2 + latentVec[5] * 0.8) * 0.26 + Math.sin(channelState.phase * 3 + latentVec[6] * 0.4) * 0.12; const aspiration = noiseValue * (0.12 + rules.breath * 0.42) + voiced * (0.86 - rules.breath * 0.34); const formantShift = rules.formantShift * style.formantWarmth * (1 + latentVec[7] * 0.08); const bandwidthTilt = 1 + Math.abs(latentVec[8]) * 0.5 + rules.breath * 0.35; const formants = [ mapSigned(latentVec[1], 260, 880) * formantShift, mapSigned(latentVec[2], 900, 2400) * formantShift, mapSigned(latentVec[3], 1800, 3600) * formantShift, ]; const bandwidths = [90, 140, 200].map((value) => value * bandwidthTilt); let output = 0;
for (let index = 0; index < FORMANT_COUNT; index += 1) { output += resonatorStep( formants[index], bandwidths[index], aspiration * (0.45 - index * 0.08), channelState.resonators, index * 2, sampleRate, ); }
return clamp(output * 0.08, -1, 1);}
function stepTable(channelState, pcmField, latentVec, rules, sampleRate, headX, headY, style, stereoOffset) { const playbackHz = clamp( rules.basePitch * rules.tableRate * (0.3 + (latentVec[0] + 1) * 0.24) * (1 + stereoOffset * 0.02), 18, sampleRate * 0.45, ); channelState.phase = wrap01(channelState.phase + playbackHz / sampleRate); const warpAmount = rules.tableWarp * style.tableWarpScale; const warpedPhase = wrap01( channelState.phase + Math.sin(channelState.phase * TAU * (1.1 + Math.abs(latentVec[3]) * 1.8) + headY * TAU) * 0.025 * warpAmount + headX * 0.17 + headY * 0.09 + latentVec[4] * 0.04, ); const primary = samplePcmField(pcmField, warpedPhase); const secondary = samplePcmField( pcmField, wrap01(warpedPhase * (1.01 + latentVec[5] * 0.03) + latentVec[6] * 0.05 + stereoOffset * 0.01), ); return clamp(primary * 0.72 + secondary * 0.28, -1, 1);}
function writeAscii(view, offset, text) { for (let i = 0; i < text.length; i += 1) { view.setUint8(offset + i, text.charCodeAt(i)); }}
export function createSonicFrameEngine(options = {}) { const source = options.source || ""; const fps = options.fps || 30; const sampleRate = options.sampleRate || 48000; const width = options.width || 128; const height = options.height || 128; const seed = options.seed ?? hashString(source || "kidlisp-wasm-sonic-frame"); const style = SOUND_STYLES[options.style] || SOUND_STYLES.default; const controlNetwork = buildNetwork(seed ^ 0x9e3779b9, GLOBAL_FEATURE_COUNT + STATE_LATENT_SIZE, [32, 32], OUTPUT_SIZE); const encoderNetwork = buildNetwork( seed ^ 0x85ebca6b, TILE_FEATURE_COUNT + STATE_LATENT_SIZE + LATENT_FIELD_CHANNELS, [24, 24], LATENT_FIELD_CHANNELS, ); const jitter = createSeededRandom(seed ^ 0xc2b2ae35); const noise = createSeededRandom(seed ^ 0x27d4eb2f);
let cells = new Float32Array(CELL_COUNT); let nextCells = new Float32Array(CELL_COUNT); let globalLatent = new Float32Array(STATE_LATENT_SIZE); let latentField = new Float32Array(TILE_GRID_X * TILE_GRID_Y * LATENT_FIELD_CHANNELS); let sampleClock = 0; let byteLeftState = 0; let byteRightState = 0; let smoothLeft = 0; let smoothRight = 0; let previousRules = null; const tonalLeftState = { phases: new Float32Array(ADDITIVE_PARTIALS) }; const tonalRightState = { phases: new Float32Array(ADDITIVE_PARTIALS) }; const vocalLeftState = { phase: 0, resonators: new Float32Array(FORMANT_COUNT * 2) }; const vocalRightState = { phase: 0, resonators: new Float32Array(FORMANT_COUNT * 2) }; const tableLeftState = { phase: jitter() }; const tableRightState = { phase: jitter() };
for (let i = 0; i < cells.length; i += 1) { cells[i] = jitter() * 2 - 1; }
for (let i = 0; i < globalLatent.length; i += 1) { globalLatent[i] = jitter() * 2 - 1; }
for (let i = 0; i < latentField.length; i += 1) { latentField[i] = jitter() * 2 - 1; }
return { synthesizeFrame(rgba, frameIndex) { const features = extractFramebufferFeatures(rgba, width, height); const controlInput = new Float32Array(GLOBAL_FEATURE_COUNT + STATE_LATENT_SIZE); controlInput.set(features, 0); controlInput.set(globalLatent, GLOBAL_FEATURE_COUNT);
const controlOutput = forwardNetwork(controlNetwork, controlInput); const nextGlobalLatent = new Float32Array(STATE_LATENT_SIZE); for (let i = 0; i < STATE_LATENT_SIZE; i += 1) { nextGlobalLatent[i] = clamp(lerp(globalLatent[i], controlOutput[i], style.latentBlend), -1, 1); } globalLatent = nextGlobalLatent;
const { field: nextField, summary: fieldSummary, flux: fieldFlux, energy: fieldEnergy } = encodeLatentField( rgba, width, height, latentField, globalLatent, encoderNetwork, style, ); latentField = nextField;
const rules = interpretRules(controlOutput, features, fieldSummary); seedPetriDish(cells, features, globalLatent); const pcm = buildPcmField(rgba, width, height);
const frameStart = Math.round(frameIndex * sampleRate / fps); const frameEnd = Math.round((frameIndex + 1) * sampleRate / fps); const sampleCount = Math.max(1, frameEnd - frameStart); const left = new Float32Array(sampleCount); const right = new Float32Array(sampleCount); const lastRules = previousRules || rules; const state = { cells, nextCells, latent: globalLatent }; const latentLeft = new Float32Array(LATENT_FIELD_CHANNELS); const latentRight = new Float32Array(LATENT_FIELD_CHANNELS); const latentMix = new Float32Array(LATENT_FIELD_CHANNELS); const expertSums = new Float32Array(EXPERT_NAMES.length); let leftPower = 0; let rightPower = 0; let stereoDiff = 0; let motionAccumulator = 0;
for (let sampleIndex = 0; sampleIndex < sampleCount; sampleIndex += 1) { const mix = sampleCount === 1 ? 1 : sampleIndex / (sampleCount - 1); const blendedRules = blendRules(lastRules, rules, mix, style); evolvePetriDish(state, features, blendedRules, sampleIndex); cells = state.cells; nextCells = state.nextCells;
const absoluteTime = sampleClock / sampleRate; const scanDrift = frameIndex / Math.max(1, fps) * blendedRules.latentDrift; const orbitPhase = absoluteTime * (0.35 + blendedRules.scanWarp * 0.3) + globalLatent[0]; const orbitX = Math.sin(orbitPhase + globalLatent[1] * 0.7) * blendedRules.scanOrbit; const orbitY = Math.cos(orbitPhase * 1.17 + globalLatent[2] * 0.6) * blendedRules.scanOrbit; const headX = wrap01((features[7] * 0.5 + 0.5) + scanDrift + absoluteTime * blendedRules.scanRateX + orbitX); const headY = wrap01((features[8] * 0.5 + 0.5) - scanDrift + absoluteTime * blendedRules.scanRateY + orbitY); const stereoSpread = 0.04 + Math.abs(blendedRules.stereoDrift) * 0.1; const leftX = wrap01(headX - stereoSpread + globalLatent[3] * 0.03); const leftY = wrap01(headY + stereoSpread * 0.5 + globalLatent[4] * 0.03); const rightX = wrap01(headX + stereoSpread + globalLatent[5] * 0.03); const rightY = wrap01(headY - stereoSpread * 0.5 + globalLatent[6] * 0.03);
sampleLatentField(latentField, leftX, leftY, latentLeft); sampleLatentField(latentField, rightX, rightY, latentRight); for (let i = 0; i < LATENT_FIELD_CHANNELS; i += 1) { latentMix[i] = (latentLeft[i] + latentRight[i]) * 0.5; }
const expertWeights = deriveExpertWeights(blendedRules, latentMix, style); for (let i = 0; i < expertWeights.length; i += 1) { expertSums[i] += expertWeights[i]; }
const tonalLeft = stepAdditive(tonalLeftState, latentLeft, blendedRules, sampleRate, -1); const tonalRight = stepAdditive(tonalRightState, latentRight, blendedRules, sampleRate, 1); const noiseLeft = noise() * 2 - 1; const noiseRight = noise() * 2 - 1; const vocalLeft = stepVocal(vocalLeftState, latentLeft, blendedRules, sampleRate, noiseLeft, style, -1); const vocalRight = stepVocal(vocalRightState, latentRight, blendedRules, sampleRate, noiseRight, style, 1); const tableLeft = stepTable(tableLeftState, pcm.field, latentLeft, blendedRules, sampleRate, leftX, leftY, style, -1); const tableRight = stepTable(tableRightState, pcm.field, latentRight, blendedRules, sampleRate, rightX, rightY, style, 1);
const t = sampleClock; const petriIndexA = (t * blendedRules.strideA + sampleIndex) % cells.length; const petriIndexB = (t * blendedRules.strideB + sampleIndex * 3) % cells.length; const petriA = cells[petriIndexA]; const petriB = cells[petriIndexB]; const petriByteA = Math.floor((petriA * 0.5 + 0.5) * 255) & 255; const petriByteB = Math.floor((petriB * 0.5 + 0.5) * 255) & 255; const byteLeftRaw = bytebeatSample(t, blendedRules, petriByteA, petriByteB) / 127.5 - 1; const byteRightRaw = bytebeatSample(t + 17, blendedRules, petriByteB, petriByteA) / 127.5 - 1; const byteLeftShaped = lerp(byteLeftRaw, Math.sin(byteLeftRaw * Math.PI * 0.5), style.byteSoftness); const byteRightShaped = lerp(byteRightRaw, Math.sin(byteRightRaw * Math.PI * 0.5), style.byteSoftness);
byteLeftState = byteLeftState * style.byteLowpass + byteLeftShaped * (1 - style.byteLowpass); byteRightState = byteRightState * style.byteLowpass + byteRightShaped * (1 - style.byteLowpass);
const livingLeft = clamp( byteLeftState * blendedRules.byteMix * style.byteMixScale * style.byteHarmonicsScale + petriA * blendedRules.petriMix * style.petriMixScale, -1, 1, ); const livingRight = clamp( byteRightState * blendedRules.byteMix * style.byteMixScale * style.byteHarmonicsScale + petriB * blendedRules.petriMix * style.petriMixScale, -1, 1, );
const rawLeft = tonalLeft * expertWeights[0] * 0.86 + vocalLeft * expertWeights[1] * 0.96 + tableLeft * expertWeights[2] * 0.92 + livingLeft * expertWeights[3] * 0.84; const rawRight = tonalRight * expertWeights[0] * 0.86 + vocalRight * expertWeights[1] * 0.96 + tableRight * expertWeights[2] * 0.92 + livingRight * expertWeights[3] * 0.84;
const pan = clamp(0.5 + blendedRules.panSkew * 0.32 * style.panScale, 0.12, 0.88); const mixedLeft = rawLeft * (1 - pan * 0.18) + rawRight * pan * 0.08 + petriB * 0.04; const mixedRight = rawRight * (0.82 + pan * 0.18) + rawLeft * (1 - pan) * 0.08 + petriA * 0.04; const gain = (0.34 + blendedRules.sparkle * 0.06 * style.sparkleScale) * style.gainScale;
smoothLeft = smoothLeft * style.outputSmoothing + mixedLeft * (1 - style.outputSmoothing); smoothRight = smoothRight * style.outputSmoothing + mixedRight * (1 - style.outputSmoothing);
left[sampleIndex] = clamp(tanh(smoothLeft * gain), -1, 1); right[sampleIndex] = clamp(tanh(smoothRight * gain), -1, 1); leftPower += left[sampleIndex] * left[sampleIndex]; rightPower += right[sampleIndex] * right[sampleIndex]; stereoDiff += Math.abs(left[sampleIndex] - right[sampleIndex]); motionAccumulator += Math.abs(orbitX) + Math.abs(orbitY); sampleClock += 1; }
previousRules = rules; return { left, right, rules, features, analysis: { expertNames: DECODER_NAMES, expertMix: Array.from(expertSums, (sum) => sum / sampleCount), rmsLeft: Math.sqrt(leftPower / sampleCount), rmsRight: Math.sqrt(rightPower / sampleCount), stereoSpread: stereoDiff / sampleCount, latentFlux: fieldFlux, latentEnergy: fieldEnergy, pcmEnergy: pcm.energy, motionSpread: motionAccumulator / sampleCount, }, }; }, };}
export function encodeStereoWav(leftChunks, rightChunks, sampleRate = 48000) { const totalSamples = leftChunks.reduce((sum, chunk) => sum + chunk.length, 0); const bytesPerSample = 2; const numChannels = 2; const dataSize = totalSamples * numChannels * bytesPerSample; const buffer = new ArrayBuffer(44 + dataSize); const view = new DataView(buffer);
writeAscii(view, 0, "RIFF"); view.setUint32(4, 36 + dataSize, true); writeAscii(view, 8, "WAVE"); writeAscii(view, 12, "fmt "); view.setUint32(16, 16, true); view.setUint16(20, 1, true); view.setUint16(22, numChannels, true); view.setUint32(24, sampleRate, true); view.setUint32(28, sampleRate * numChannels * bytesPerSample, true); view.setUint16(32, numChannels * bytesPerSample, true); view.setUint16(34, 16, true); writeAscii(view, 36, "data"); view.setUint32(40, dataSize, true);
let offset = 44; for (let i = 0; i < leftChunks.length; i += 1) { const left = leftChunks[i]; const right = rightChunks[i]; for (let sample = 0; sample < left.length; sample += 1) { view.setInt16(offset, clamp(left[sample], -1, 1) * 0x7fff, true); offset += 2; view.setInt16(offset, clamp(right[sample], -1, 1) * 0x7fff, true); offset += 2; } }
return Buffer.from(buffer);}