Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

11.5 KB
Raw Blame

API surface — esengine/sound

Symbols: 0 public · 0 beta · 63 experimental · 0 deprecated

CompiledMusic — interface @experimental

barSeconds: number
events: MusicEvent[]
notes: string[]
parts: { pattern: string; at: number; bars: number; }[]
seconds: number

DYNAMICS — const @experimental

readonly ["soft", "normal", "loud"]

MAX_MUSIC_SECONDS — const @experimental

240

MAX_SOUND_SECONDS — const @experimental

30

MAX_SOUND_VARIANTS — const @experimental

8

MUSIC_SOURCE_EXT — const @experimental

".esmusic"

MUSIC_SOURCE_VERSION — const @experimental

1

MusicEdit — type @experimental

| { op: 'instrument'; name: string; value: MusicInstrument | null }
    | { op: 'pattern'; name: string; value: MusicPattern | null }
    | { op: 'track'; pattern: string; track: string; steps: string | null }
    | { op: 'settings'; fields: Record<string, unknown> }

MusicEvent — interface @experimental

at: number
hard: number
instrument: string
loud: number
mark: 0 | 1 | -1
midi: number | null
outside: boolean
part: number
seconds: number
slur: boolean | undefined
sounds: number | undefined
tied: boolean | undefined

MusicInstrument — interface @experimental

attack: number | undefined
follow: boolean | undefined
gain: number | undefined
highcut: number | undefined
layers: readonly SoundLayer[] | undefined
legato: number | boolean | undefined
lowcut: number | undefined
octave: number | undefined
pan: number | undefined
pedal: boolean | undefined
release: number | undefined
reverb: number | undefined
samples: readonly MusicSample[] | undefined
scale: "dorian" | "gong" | "harmonic" | "jue" | "lydian" | "major" | "minor" | "mixolydian" | "pentatonic" | "pentatonicMinor" | "phrygian" | "shang" | "yu" | "zhi" | undefined

MusicPattern — interface @experimental

bars: number
chords: readonly number[] | undefined
div: number | undefined
dynamics: Readonly<Record<string, readonly number[]>> | undefined
tracks: Readonly<Record<string, string>>

MusicSample — interface @experimental

cutoff: number | undefined
dynamic: "loud" | "normal" | "soft" | undefined
file: string
gain: number | undefined
high: string | number | undefined
loop: boolean | readonly [number, number] | undefined
low: string | number | undefined
note: string | number
tune: number | undefined

MusicSource — interface @experimental

beats: number | undefined
fadeIn: number | undefined
fadeOut: number | undefined
gain: number | undefined
humanize: number | undefined
instruments: Readonly<Record<string, MusicInstrument>>
intro: number | undefined
key: string
loop: boolean | undefined
master: { compress?: number; low?: number; high?: number; } | undefined
patterns: Readonly<Record<string, MusicPattern>>
rate: number | undefined
reverb: { size?: number; mix?: number; } | undefined
rubato: number | undefined
scale: "dorian" | "gong" | "harmonic" | "jue" | "lydian" | "major" | "minor" | "mixolydian" | "pentatonic" | "pentatonicMinor" | "phrygian" | "shang" | "yu" | "zhi" | undefined
seed: number | undefined
song: readonly SongPart[]
stems: boolean | undefined
swing: number | undefined
tempo: number
version: number | undefined

NOISE_COLORS — const @experimental

readonly ["white", "pink", "brown"]

REVERB_KINDS — const @experimental

readonly ["room", "open"]

RenderedMusic — interface @experimental

barSeconds: number
channels: Float32Array<ArrayBufferLike>[]
events: MusicEvent[]
instruments: Record<string, { notes: number; low?: string; high?: string; levelDb: number; }>
join: { ends: string[]; begins: string[]; endDb: number; startDb: number; } | null
loopStart: number
notes: string[]
parts: { pattern: string; at: number; bars: number; }[]
peak: number
rate: number
rms: number
seconds: number
stems: Record<string, Float32Array<ArrayBufferLike>[]> | null
tailSeconds: number

RenderedSound — interface @experimental

channels: Float32Array<ArrayBufferLike>[]
layers: { id?: string; source: string; from: number; to: number; peak: number; strikes?: number; }[]
notes: string[]
peak: number
rate: number
rms: number
seconds: number

SCALES — const @experimental

{ readonly pentatonic: readonly [0, 2, 4, 7, 9]; readonly pentatonicMinor: readonly [0, 3, 5, 7, 10]; readonly gong: readonly [0, 2, 4, 7, 9]; readonly shang: readonly [0, 2, 5, 7, 10]; readonly jue: readonly [0, 3, 5, 8, 10]; readonly zhi: readonly [0, 2, 5, 7, 9]; readonly yu: readonly [0, 3, 5, 7, 10]; readonly major: readonly [0, 2, 4, 5, 7, 9, 11]; readonly minor: readonly [0, 2, 3, 5, 7, 8, 10]; readonly dorian: readonly [0, 2, 3, 5, 7, 9, 10]; readonly phrygian: readonly [0, 1, 3, 5, 7, 8, 10]; readonly lydian: readonly [0, 2, 4, 6, 7, 9, 11]; readonly mixolydian: readonly [0, 2, 4, 5, 7, 9, 10]; readonly harmonic: readonly [0, 2, 3, 5, 7, 8, 11]; }

SOUND_FILTERS — const @experimental

readonly ["lowpass", "highpass", "bandpass", "notch", "peak"]

SOUND_RATES — const @experimental

readonly [22050, 44100, 48000]

SOUND_RENDER_REVISION — const @experimental

"2"

SOUND_SOURCES — const @experimental

readonly ["sine", "triangle", "saw", "square", "noise", "modes", "impulse", "sample", "group"]

SOUND_SOURCE_EXT — const @experimental

".essound"

SOUND_SOURCE_VERSION — const @experimental

1

SampleData — interface @experimental

channels: readonly Float32Array<ArrayBufferLike>[]
rate: number

ScaleName — type @experimental

keyof typeof SCALES

SongPart — type @experimental

string | { pattern: string; without?: readonly string[]; only?: readonly string[] }

SoundCurve — type @experimental

number | readonly (readonly [number, number])[]

SoundEdit — type @experimental

| { op: 'set'; layer: string | number; fields: Record<string, unknown> }
    | { op: 'insert'; layer: SoundLayer; before?: string | number; after?: string | number; into?: string }
    | { op: 'remove'; layer: string | number }
    | { op: 'settings'; fields: Partial<Omit<SoundSource, 'layers' | 'version'>> }

SoundFilter — interface @experimental

freq: SoundCurve
gain: number | undefined
q: number | undefined
type: "bandpass" | "highpass" | "lowpass" | "notch" | "peak"

SoundJob — interface @experimental

files: Record<string, ArrayBuffer>
path: string
source: string

SoundLayer — interface @experimental

attack: number | undefined
band: readonly [number, number] | undefined
color: "brown" | "pink" | "white" | undefined
decay: number | undefined
drive: number | undefined
file: string | undefined
filters: readonly SoundFilter[] | undefined
fm: { ratio: number; index: SoundCurve; } | undefined
freq: SoundCurve | undefined
from: number | undefined
gain: SoundCurve | undefined
id: string | undefined
layers: readonly SoundLayer[] | undefined
length: number | undefined
modes: readonly (readonly [number, number, number])[] | undefined
mute: boolean | undefined
pan: number | undefined
release: number | undefined
repeat: { count: number; every: number; gain?: number; pitch?: number; jitter?: number; faster?: number; } | undefined
scatter: { count: number; over: number; early?: number; pitch?: readonly [number, number]; gain?: readonly [number, number]; pan?: number; fade?: number; } | undefined
seed: number | undefined
source: "group" | "impulse" | "modes" | "noise" | "sample" | "saw" | "sine" | "square" | "triangle"
speed: number | undefined
start: number | undefined
tail: { decay: number; mix: number; } | undefined
tremolo: { rate: number; depth: number; } | undefined
vibrato: { rate: number; depth: number; } | undefined
wide: number | undefined
width: number | undefined

SoundRecording — interface @experimental

channels: readonly Float32Array<ArrayBufferLike>[]
rate: number

SoundSource — interface @experimental

duration: number
echo: { time: number; feedback?: number; mix?: number; } | undefined
gain: number | undefined
highpass: number | undefined
layers: readonly SoundLayer[]
loop: boolean | undefined
lowpass: number | undefined
normalize: boolean | undefined
rate: number | undefined
reference: string | undefined
reverb: { size?: number; mix?: number; kind?: (typeof REVERB_KINDS)[number]; } | undefined
variants: number | undefined
vary: number | undefined
version: number | undefined

SoundSourceKind — type @experimental

(typeof SOUND_SOURCES)[number]

Step — type @experimental

| { kind: 'rest' }
    | { kind: 'hold' }
    | { kind: 'hit'; loud: number }
    | { kind: 'notes'; loud: number; notes: StepNote[] }

StepNote — interface @experimental

alter: number
degree: number
octave: number

applyMusicEdits — function @experimental

(source: MusicSource, edits: readonly MusicEdit[]): MusicSource

applySoundEdits — function @experimental

(source: SoundSource, edits: readonly SoundEdit[]): SoundSource

compileMusic — function @experimental

(source: MusicSource): CompiledMusic

convolve — function @experimental

(a: Float32Array, b: Float32Array, keep: number): Float32Array

decodeWav — function @experimental

(bytes: Uint8Array): RenderedSound

encodeWav — function @experimental

(sound: { rate: number; channels: readonly Float32Array[]; }): Uint8Array

fft — function @experimental

(re: Float64Array, im: Float64Array): void

installAudioRecipes — function @experimental

(): void

makeSound — function @experimental

(job: SoundJob): ArrayBuffer

midiOf — function @experimental

(note: unknown): number | null

musicSampleFiles — function @experimental

(source: MusicSource): string[]

musicSeconds — function @experimental

(source: MusicSource): number

noteName — const @experimental

(midi: number) => string

parseTrack — function @experimental

(text: string, bars: number, stepsToBar: number, where: string, degrees?: number): Step[]

placeResponse — function @experimental

(rate: number, size: number, kind: "open" | "room", side: number): Float32Array

renderMusic — function @experimental

(source: MusicSource, given?: Readonly<Record<string, SampleData>>): RenderedMusic

renderSound — function @experimental

(source: SoundSource, variant?: number, at?: { pitch?: number; seed?: number; raw?: boolean; given?: Readonly<Record<string, SoundRecording>>; }): RenderedSound

renderSoundVariants — function @experimental

(source: SoundSource, given?: Readonly<Record<string, SoundRecording>>): RenderedSound[]

samplePitch — function @experimental

(data: SampleData, near: number): number | null

sampleZone — function @experimental

(instrument: MusicInstrument, midi: number | null, mark: number, turn: number): { index: number; matched: boolean; }

soundFromSamples — function @experimental

(rate: number, channels: readonly Float32Array[]): RenderedSound

soundNeeds — function @experimental

(source: string, path: string): string[]

soundSampleFiles — function @experimental

(source: Pick<SoundSource, "layers">): string[]

tonicOf — const @experimental

(key: string) => number

validateMusicSource — function @experimental

(raw: unknown): MusicSource

validateSoundSource — function @experimental

(raw: unknown): SoundSource