godothub/godot-minigame / skills
godot-wechat-minigame-adapter
UnverifiedApply the bundled self-contained Godot WeChat Mini Game adapter kit to an official Godot checkout. Use when the user wants to port official Godot to WeChat Mini Game, refresh a nearby 4.6-based port, or inspect the shipped patch/source bundle for WXMEMFS, `wx.request`, audio cleanup, display/input, WXGLX dual-path rendering, `.wasm.br`, and `wx.exitMiniProgram`. This skill is version-locked to the bundled upstream base and must not be described as a generic “Godot 4.x” patch dump.
sources/godot-4.6.2-rc-a16e481cf4/platform/web/js/libs/library_godot_audio.js
View on GitHub/**************************************************************************/
/* library_godot_audio.js */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
/**
* @typedef { "disabled" | "forward" | "backward" | "pingpong" } LoopMode
*/
/**
* @typedef {{
* id: string
* audioBuffer: AudioBuffer
* }} SampleParams
* @typedef {{
* numberOfChannels?: number
* sampleRate?: number
* loopMode?: LoopMode
* loopBegin?: number
* loopEnd?: number
* }} SampleOptions
*/
/**
* Represents a sample, memory-wise.
* @class
*/
class Sample {
/**
* Returns a `Sample`.
* @param {string} id Id of the `Sample` to get.
* @returns {Sample}
* @throws {ReferenceError} When no `Sample` is found
*/
static getSample(id) {
if (!GodotAudio.samples.has(id)) {
throw new ReferenceError(`Could not find sample "${id}"`);
}
return GodotAudio.samples.get(id);
}
/**
* Returns a `Sample` or `null`, if it doesn't exist.
* @param {string} id Id of the `Sample` to get.
* @returns {Sample?}
*/
static getSampleOrNull(id) {
return GodotAudio.samples.get(id) ?? null;
}
/**
* Creates a `Sample` based on the params. Will register it to the
* `GodotAudio.samples` registry.
* @param {SampleParams} params Base params
* @param {SampleOptions | undefined} options Optional params.
* @returns {Sample}
*/
static create(params, options = {}) {
const sample = new GodotAudio.Sample(params, options);
GodotAudio.samples.set(params.id, sample);
return sample;
}
/**
* Deletes a `Sample` based on the id.
* @param {string} id `Sample` id to delete
* @returns {void}
*/
static delete(id) {
GodotAudio.samples.delete(id);
}
/**
* `Sample` constructor.
* @param {SampleParams} params Base params
* @param {SampleOptions | undefined} options Optional params.
*/
constructor(params, options = {}) {
/** @type {string} */
this.id = params.id;
/** @type {AudioBuffer} */
this._audioBuffer = null;
/** @type {number} */
this.numberOfChannels = options.numberOfChannels ?? 2;
/** @type {number} */
this.sampleRate = options.sampleRate ?? 44100;
/** @type {LoopMode} */
this.loopMode = options.loopMode ?? "disabled";
/** @type {number} */
this.loopBegin = options.loopBegin ?? 0;
/** @type {number} */
this.loopEnd = options.loopEnd ?? 0;
this.setAudioBuffer(params.audioBuffer);
}
/**
* Gets the audio buffer of the sample.
* @returns {AudioBuffer}
*/
getAudioBuffer() {
return this._duplicateAudioBuffer();
}
/**
* Sets the audio buffer of the sample.
* @param {AudioBuffer} val The audio buffer to set.
* @returns {void}
*/
setAudioBuffer(val) {
this._audioBuffer = val;
}
/**
* Clears the current sample.
* @returns {void}
*/
clear() {
this.setAudioBuffer(null);
GodotAudio.Sample.delete(this.id);
}
/**
* Returns a duplicate of the stored audio buffer.
* @returns {AudioBuffer}
*/
_duplicateAudioBuffer() {
if (this._audioBuffer == null) {
throw new Error("couldn't duplicate a null audioBuffer");
}
/** @type {Array<Float32Array>} */
const channels = new Array(this._audioBuffer.numberOfChannels);
for (let i = 0; i < this._audioBuffer.numberOfChannels; i++) {
const channel = new Float32Array(this._audioBuffer.getChannelData(i));
channels[i] = channel;
}
const buffer = GodotAudio.ctx.createBuffer(
this.numberOfChannels,
this._audioBuffer.length,
this._audioBuffer.sampleRate
);
for (let i = 0; i < channels.length; i++) {
buffer.copyToChannel(channels[i], i, 0);
}
return buffer;
}
}
/**
* Represents a `SampleNode` linked to a `Bus`.
* @class
*/
class SampleNodeBus {
/**
* Creates a new `SampleNodeBus`.
* @param {Bus} bus The bus related to the new `SampleNodeBus`.
* @returns {SampleNodeBus}
*/
static create(bus) {
return new GodotAudio.SampleNodeBus(bus);
}
/**
* `SampleNodeBus` constructor.
* @param {Bus} bus The bus related to the new `SampleNodeBus`.
*/
constructor(bus) {
const NUMBER_OF_WEB_CHANNELS = 6;
/** @type {Bus} */
this._bus = bus;
/** @type {ChannelSplitterNode} */
this._channelSplitter = GodotAudio.ctx.createChannelSplitter(NUMBER_OF_WEB_CHANNELS);
/** @type {GainNode} */
this._l = GodotAudio.ctx.createGain();
/** @type {GainNode} */
this._r = GodotAudio.ctx.createGain();
/** @type {GainNode} */
this._sl = GodotAudio.ctx.createGain();
/** @type {GainNode} */
this._sr = GodotAudio.ctx.createGain();
/** @type {GainNode} */
this._c = GodotAudio.ctx.createGain();
/** @type {GainNode} */
this._lfe = GodotAudio.ctx.createGain();
/** @type {ChannelMergerNode} */
this._channelMerger = GodotAudio.ctx.createChannelMerger(NUMBER_OF_WEB_CHANNELS);
// WeChat Mini Game doesn't support chained connect() calls
// Must break them into separate statements
this._channelSplitter.connect(this._l, GodotAudio.WebChannel.CHANNEL_L);
this._l.connect(this._channelMerger, GodotAudio.WebChannel.CHANNEL_L, GodotAudio.WebChannel.CHANNEL_L);
this._channelSplitter.connect(this._r, GodotAudio.WebChannel.CHANNEL_R);
this._r.connect(this._channelMerger, GodotAudio.WebChannel.CHANNEL_L, GodotAudio.WebChannel.CHANNEL_R);
this._channelSplitter.connect(this._sl, GodotAudio.WebChannel.CHANNEL_SL);
this._sl.connect(this._channelMerger, GodotAudio.WebChannel.CHANNEL_L, GodotAudio.WebChannel.CHANNEL_SL);
this._channelSplitter.connect(this._sr, GodotAudio.WebChannel.CHANNEL_SR);
this._sr.connect(this._channelMerger, GodotAudio.WebChannel.CHANNEL_L, GodotAudio.WebChannel.CHANNEL_SR);
this._channelSplitter.connect(this._c, GodotAudio.WebChannel.CHANNEL_C);
this._c.connect(this._channelMerger, GodotAudio.WebChannel.CHANNEL_L, GodotAudio.WebChannel.CHANNEL_C);
this._channelSplitter.connect(this._lfe, GodotAudio.WebChannel.CHANNEL_L);
this._lfe.connect(this._channelMerger, GodotAudio.WebChannel.CHANNEL_L, GodotAudio.WebChannel.CHANNEL_LFE);
this._channelMerger.connect(this._bus.getInputNode());
}
/**
* Returns the input node.
* @returns {AudioNode}
*/
getInputNode() {
return this._channelSplitter;
}
/**
* Returns the output node.
* @returns {AudioNode}
*/
getOutputNode() {
return this._channelMerger;
}
/**
* Sets the volume for each (split) channel.
* @param {Float32Array} volume Volume array from the engine for each channel.
* @returns {void}
*/
setVolume(volume) {
if (volume.length !== GodotAudio.MAX_VOLUME_CHANNELS) {
throw new Error(`Volume length isn't "${GodotAudio.MAX_VOLUME_CHANNELS}", is ${volume.length} instead`);
}
this._l.gain.value = volume[GodotAudio.GodotChannel.CHANNEL_L] ?? 0;
this._r.gain.value = volume[GodotAudio.GodotChannel.CHANNEL_R] ?? 0;
this._sl.gain.value = volume[GodotAudio.GodotChannel.CHANNEL_SL] ?? 0;
this._sr.gain.value = volume[GodotAudio.GodotChannel.CHANNEL_SR] ?? 0;
this._c.gain.value = volume[GodotAudio.GodotChannel.CHANNEL_C] ?? 0;
this._lfe.gain.value = volume[GodotAudio.GodotChannel.CHANNEL_LFE] ?? 0;
}
/**
* Clears the current `SampleNodeBus` instance.
* @returns {void}
*/
clear() {
this._bus = null;
this._channelSplitter.disconnect();
this._channelSplitter = null;
this._l.disconnect();
this._l = null;
this._r.disconnect();
this._r = null;
this._sl.disconnect();
this._sl = null;
this._sr.disconnect();
this._sr = null;
this._c.disconnect();
this._c = null;
this._lfe.disconnect();
this._lfe = null;
this._channelMerger.disconnect();
this._channelMerger = null;
}
}
/**
* @typedef {{
* id: string
* streamObjectId: string
* busIndex: number
* }} SampleNodeParams
* @typedef {{
* offset?: number
* playbackRate?: number
* startTime?: number
* pitchScale?: number
* loopMode?: LoopMode
* volume?: Float32Array
* start?: boolean
* }} SampleNodeOptions
*/
/**
* Represents an `AudioNode` of a `Sample`.
* @class
*/
class SampleNode {
/**
* Returns a `SampleNode`.
* @param {string} id Id of the `SampleNode`.
* @returns {SampleNode}
* @throws {ReferenceError} When no `SampleNode` is not found
*/
static getSampleNode(id) {
if (!GodotAudio.sampleNodes.has(id)) {
throw new ReferenceError(`Could not find sample node "${id}"`);
}
return GodotAudio.sampleNodes.get(id);
}
/**
* Returns a `SampleNode`, returns null if not found.
* @param {string} id Id of the SampleNode.
* @returns {SampleNode?}
*/
static getSampleNodeOrNull(id) {
return GodotAudio.sampleNodes.get(id) ?? null;
}
/**
* Stops a `SampleNode` by id.
* @param {string} id Id of the `SampleNode` to stop.
* @returns {void}
*/
static stopSampleNode(id) {
const sampleNode = GodotAudio.SampleNode.getSampleNodeOrNull(id);
if (sampleNode == null) {
return;
}
sampleNode.stop();
}
/**
* Pauses the `SampleNode` by id.
* @param {string} id Id of the `SampleNode` to pause.
* @param {boolean} enable State of the pause
* @returns {void}
*/
static pauseSampleNode(id, enable) {
const sampleNode = GodotAudio.SampleNode.getSampleNodeOrNull(id);
if (sampleNode == null) {
return;
}
sampleNode.pause(enable);
}
/**
* Creates a `SampleNode` based on the params. Will register the `SampleNode` to
* the `GodotAudio.sampleNodes` regisery.
* @param {SampleNodeParams} params Base params.
* @param {SampleNodeOptions | undefined} options Optional params.
* @returns {SampleNode}
*/
static create(params, options = {}) {
const sampleNode = new GodotAudio.SampleNode(params, options);
GodotAudio.sampleNodes.set(params.id, sampleNode);
return sampleNode;
}
/**
* Deletes a `SampleNode` based on the id.
* @param {string} id Id of the `SampleNode` to delete.
* @returns {void}
*/
static delete(id) {
GodotAudio.deleteSampleNode(id);
}
/**
* @param {SampleNodeParams} params Base params
* @param {SampleNodeOptions | undefined} options Optional params.
*/
constructor(params, options = {}) {
/** @type {string} */
this.id = params.id;
/** @type {string} */
this.streamObjectId = params.streamObjectId;
/** @type {number} */
this.offset = options.offset ?? 0;
/** @type {number} */
this._playbackPosition = options.offset;
/** @type {number} */
this.startTime = options.startTime ?? 0;
/** @type {boolean} */
this.isPaused = false;
/** @type {boolean} */
this.isStarted = false;
/** @type {boolean} */
this.isCleared = false;
/** @type {boolean} */
this.isCanceled = false;
/** @type {number} */
this.pauseTime = 0;
/** @type {number} */
this._playbackRate = 44100;
/** @type {LoopMode} */
this.loopMode = options.loopMode ?? this.getSample().loopMode ?? "disabled";
/** @type {number} */
this._pitchScale = options.pitchScale ?? 1;
/** @type {number} */
this._sourceStartTime = 0;
/** @type {Map<Bus, SampleNodeBus>} */
this._sampleNodeBuses = new Map();
/** @type {AudioBufferSourceNode | null} */
this._source = GodotAudio.ctx.createBufferSource();
this._onended = null;
/** @type {AudioWorkletNode | null} */
this._positionWorklet = null;
this.setPlaybackRate(options.playbackRate ?? 44100);
this._source.buffer = this.getSample().getAudioBuffer();
this._addEndedListener();
const bus = GodotAudio.Bus.getBus(params.busIndex);
const sampleNodeBus = this.getSampleNodeBus(bus);
sampleNodeBus.setVolume(options.volume);
this.connectAudioContext(options.start);
}
/**
* Gets the playback rate.
* @returns {number}
*/
getPlaybackRate() {
return this._playbackRate;
}
/**
* Gets the playback position.
* @returns {number}
*/
getPlaybackPosition() {
return this._playbackPosition;
}
/**
* Sets the playback rate.
* @param {number} val Value to set.
* @returns {void}
*/
setPlaybackRate(val) {
this._playbackRate = val;
this._syncPlaybackRate();
}
/**
* Gets the pitch scale.
* @returns {number}
*/
getPitchScale() {
return this._pitchScale;
}
/**
* Sets the pitch scale.
* @param {number} val Value to set.
* @returns {void}
*/
setPitchScale(val) {
this._pitchScale = val;
this._syncPlaybackRate();
}
/**
* Returns the linked `Sample`.
* @returns {Sample}
*/
getSample() {
return GodotAudio.Sample.getSample(this.streamObjectId);
}
/**
* Returns the output node.
* @returns {AudioNode}
*/
getOutputNode() {
return this._source;
}
/**
* Starts the `SampleNode`.
* @returns {void}
*/
start() {
if (this.isStarted) {
return;
}
this._resetSourceStartTime();
this._source.start(this.startTime, this.offset);
this.isStarted = true;
}
/**
* Stops the `SampleNode`.
* @returns {void}
*/
stop() {
this.clear();
}
/**
* Restarts the `SampleNode`.
*/
restart() {
this.isPaused = false;
this.pauseTime = 0;
this._resetSourceStartTime();
this._restart();
}
/**
* Pauses the `SampleNode`.
* @param {boolean} [enable=true] State of the pause.
* @returns {void}
*/
pause(enable = true) {
if (enable) {
this._pause();
return;
}
this._unpause();
}
/**
* Connects an AudioNode to the output node of this `SampleNode`.
* @param {AudioNode} node AudioNode to connect.
* @returns {void}
*/
connect(node) {
return this.getOutputNode().connect(node);
}
/**
* Sets the volumes of the `SampleNode` for each buses passed in parameters.
* @param {Array<Bus>} buses
* @param {Float32Array} volumes
*/
setVolumes(buses, volumes) {
for (let busIdx = 0; busIdx < buses.length; busIdx++) {
const sampleNodeBus = this.getSampleNodeBus(buses[busIdx]);
sampleNodeBus.setVolume(
volumes.slice(
busIdx * GodotAudio.MAX_VOLUME_CHANNELS,
busIdx * GodotAudio.MAX_VOLUME_CHANNELS + GodotAudio.MAX_VOLUME_CHANNELS
)
);
}
}
/**
* Returns the SampleNodeBus based on the bus in parameters.
* @param {Bus} bus Bus to get the SampleNodeBus from.
* @returns {SampleNodeBus}
*/
getSampleNodeBus(bus) {
if (!this._sampleNodeBuses.has(bus)) {
const sampleNodeBus = GodotAudio.SampleNodeBus.create(bus);
this._sampleNodeBuses.set(bus, sampleNodeBus);
this._source.connect(sampleNodeBus.getInputNode());
}
return this._sampleNodeBuses.get(bus);
}
/**
* Sets up and connects the source to the GodotPositionReportingProcessor
* If the worklet module is not loaded in, it will be added
*/
async connectAudioContext(start) {
if (start) {
this._source.start();
}
}
/**
* Clears the `SampleNode`.
* @returns {void}
*/
clear() {
this.isCanceled = true;
this.isPaused = false;
this.pauseTime = 0;
this.isCleared = true;
if (this._source != null) {
this._source.onended = null;
this._onended = null;
if (this.isStarted) {
this._source.stop();
}
this._source.disconnect();
this._source = null;
}
for (const sampleNodeBus of this._sampleNodeBuses.values()) {
sampleNodeBus.clear();
}
this._sampleNodeBuses.clear();
if (this._positionWorklet) {
this._positionWorklet.disconnect();
this._positionWorklet.port.onmessage = null;
GodotAudio.audioPositionWorkletNodes.push(this._positionWorklet);
this._positionWorklet = null;
}
GodotAudio.SampleNode.delete(this.id);
}
/**
* Resets the source start time
* @returns {void}
*/
_resetSourceStartTime() {
this._sourceStartTime = GodotAudio.ctx.currentTime;
}
/**
* Syncs the `AudioNode` playback rate based on the `SampleNode` playback rate and pitch scale.
* @returns {void}
*/
_syncPlaybackRate() {
this._source.playbackRate.value = this.getPlaybackRate() * this.getPitchScale();
}
/**
* Restarts the `SampleNode`.
* Honors `isPaused` and `pauseTime`.
* @returns {void}
*/
_restart() {
if (this._source != null) {
this._source.disconnect();
}
this._source = GodotAudio.ctx.createBufferSource();
this._source.buffer = this.getSample().getAudioBuffer();
// Make sure that we connect the new source to the sample node bus.
for (const sampleNodeBus of this._sampleNodeBuses.values()) {
this.connect(sampleNodeBus.getInputNode());
}
this._addEndedListener();
const pauseTime = this.isPaused ? this.pauseTime : 0;
if (this._positionWorklet != null) {
this._positionWorklet.port.postMessage({ type: "clear" });
this._source.connect(this._positionWorklet);
}
this.connectAudioContext();
this._source.start(this.startTime, this.offset + pauseTime);
this.isStarted = true;
}
/**
* Pauses the `SampleNode`.
* @returns {void}
*/
_pause() {
if (!this.isStarted) {
return;
}
this.isPaused = true;
this.pauseTime = (GodotAudio.ctx.currentTime - this._sourceStartTime) / this.getPlaybackRate();
this._source.stop();
}
/**
* Unpauses the `SampleNode`.
* @returns {void}
*/
_unpause() {
this._restart();
this.isPaused = false;
this.pauseTime = 0;
}
/**
* Adds an "ended" listener to the source node to repeat it if necessary.
* @returns {void}
*/
_addEndedListener() {
if (this._onended != null) {
this._source.onended = null;
}
const self = this;
if (this.isPaused || this.isCleared) {
return;
}
/** @type {SampleNode} */
// eslint-disable-next-line consistent-this
this._onended = (_) => {
if (self.isPaused) {
return;
}
switch (self.getSample().loopMode) {
case "disabled":
self.stop();
break;
case "forward":
case "backward":
self.restart();
break;
default:
// do nothing
}
};
this._source.onended = this._onended;
}
}
/**
* Collection of nodes to represents a Godot Engine audio bus.
* @class
*/
class Bus {
/**
* Returns the number of registered buses.
* @returns {number}
*/
static getCount() {
return GodotAudio.buses.length;
}
/**
* Sets the number of registered buses.
* Will delete buses if lower than the current number.
* @param {number} val Count of registered buses.
* @returns {void}
*/
static setCount(val) {
const buses = GodotAudio.buses;
if (val === buses.length) {
return;
}
if (val < buses.length) {
// TODO: what to do with nodes connected to the deleted buses?
const deletedBuses = buses.slice(val);
for (let i = 0; i < deletedBuses.length; i++) {
const deletedBus = deletedBuses[i];
deletedBus.clear();
}
GodotAudio.buses = buses.slice(0, val);
return;
}
for (let i = GodotAudio.buses.length; i < val; i++) {
GodotAudio.Bus.create();
}
}
/**
* Returns a `Bus` based on it's index number.
* @param {number} index
* @returns {Bus}
* @throws {ReferenceError} If the index value is outside the registry.
*/
static getBus(index) {
if (index < 0 || index >= GodotAudio.buses.length) {
throw new ReferenceError(`invalid bus index "${index}"`);
}
return GodotAudio.buses[index];
}
/**
* Returns a `Bus` based on it's index number. Returns null if it doesn't exist.
* @param {number} index
* @returns {Bus?}
*/
static getBusOrNull(index) {
if (index < 0 || index >= GodotAudio.buses.length) {
return null;
}
return GodotAudio.buses[index];
}
/**
* Move a bus from an index to another.
* @param {number} fromIndex From index
* @param {number} toIndex To index
* @returns {void}
*/
static move(fromIndex, toIndex) {
const movedBus = GodotAudio.Bus.getBusOrNull(fromIndex);
if (movedBus == null) {
return;
}
const buses = GodotAudio.buses.filter((_, i) => i !== fromIndex);
// Inserts at index.
buses.splice(toIndex - 1, 0, movedBus);
GodotAudio.buses = buses;
}
/**
* Adds a new bus at the specified index.
* @param {number} index Index to add a new bus.
* @returns {void}
*/
static addAt(index) {
const newBus = GodotAudio.Bus.create();
if (index !== newBus.getId()) {
GodotAudio.Bus.move(newBus.getId(), index);
}
}
/**
* Creates a `Bus` and registers it.
* @returns {Bus}
*/
static create() {
const newBus = new GodotAudio.Bus();
const isFirstBus = GodotAudio.buses.length === 0;
GodotAudio.buses.push(newBus);
if (isFirstBus) {
newBus.setSend(null);
} else {
newBus.setSend(GodotAudio.Bus.getBus(0));
}
return newBus;
}
/**
* `Bus` constructor.
*/
constructor() {
/** @type {Set<SampleNode>} */
this._sampleNodes = new Set();
/** @type {boolean} */
this.isSolo = false;
/** @type {Bus?} */
this._send = null;
/** @type {GainNode} */
this._gainNode = GodotAudio.ctx.createGain();
/** @type {GainNode} */
this._soloNode = GodotAudio.ctx.createGain();
/** @type {GainNode} */
this._muteNode = GodotAudio.ctx.createGain();
this._gainNode.connect(this._soloNode);
this._soloNode.connect(this._muteNode);
}
/**
* Returns the current id of the bus (its index).
* @returns {number}
*/
getId() {
return GodotAudio.buses.indexOf(this);
}
/**
* Returns the bus volume db value.
* @returns {number}
*/
getVolumeDb() {
return GodotAudio.linear_to_db(this._gainNode.gain.value);
}
/**
* Sets the bus volume db value.
* @param {number} val Value to set
* @returns {void}
*/
setVolumeDb(val) {
const linear = GodotAudio.db_to_linear(val);
if (isFinite(linear)) {
this._gainNode.gain.value = linear;
}
}
/**
* Returns the "send" bus.
* If null, this bus sends its contents directly to the output.
* If not null, this bus sends its contents to another bus.
* @returns {Bus?}
*/
getSend() {
return this._send;
}
/**
* Sets the "send" bus.
* If null, this bus sends its contents directly to the output.
* If not null, this bus sends its contents to another bus.
*
* **Note:** if null, `getId()` must be equal to 0. Otherwise, it will throw.
* @param {Bus?} val
* @returns {void}
* @throws {Error} When val is `null` and `getId()` isn't equal to 0
*/
setSend(val) {
this._send = val;
if (val == null) {
if (this.getId() == 0) {
this.getOutputNode().connect(GodotAudio.ctx.destination);
return;
}
throw new Error(
`Cannot send to "${val}" without the bus being at index 0 (current index: ${this.getId()})`
);
}
this.connect(val);
}
/**
* Returns the input node of the bus.
* @returns {AudioNode}
*/
getInputNode() {
return this._gainNode;
}
/**
* Returns the output node of the bus.
* @returns {AudioNode}
*/
getOutputNode() {
return this._muteNode;
}
/**
* Sets the mute status of the bus.
* @param {boolean} enable
*/
mute(enable) {
this._muteNode.gain.value = enable ? 0 : 1;
}
/**
* Sets the solo status of the bus.
* @param {boolean} enable
*/
solo(enable) {
if (this.isSolo === enable) {
return;
}
if (enable) {
if (GodotAudio.busSolo != null && GodotAudio.busSolo !== this) {
GodotAudio.busSolo._disableSolo();
}
this._enableSolo();
return;
}
this._disableSolo();
}
/**
* Wrapper to simply add a sample node to the bus.
* @param {SampleNode} sampleNode `SampleNode` to remove
* @returns {void}
*/
addSampleNode(sampleNode) {
this._sampleNodes.add(sampleNode);
sampleNode.getOutputNode().connect(this.getInputNode());
}
/**
* Wrapper to simply remove a sample node from the bus.
* @param {SampleNode} sampleNode `SampleNode` to remove
* @returns {void}
*/
removeSampleNode(sampleNode) {
this._sampleNodes.delete(sampleNode);
sampleNode.getOutputNode().disconnect();
}
/**
* Wrapper to simply connect to another bus.
* @param {Bus} bus
* @returns {void}
*/
connect(bus) {
if (bus == null) {
throw new Error("cannot connect to null bus");
}
this.getOutputNode().disconnect();
this.getOutputNode().connect(bus.getInputNode());
return bus;
}
/**
* Clears the current bus.
* @returns {void}
*/
clear() {
GodotAudio.buses = GodotAudio.buses.filter((v) => v !== this);
}
_syncSampleNodes() {
const sampleNodes = Array.from(this._sampleNodes);
for (let i = 0; i < sampleNodes.length; i++) {
const sampleNode = sampleNodes[i];
sampleNode.getOutputNode().disconnect();
sampleNode.getOutputNode().connect(this.getInputNode());
}
}
/**
* Process to enable solo.
* @returns {void}
*/
_enableSolo() {
this.isSolo = true;
GodotAudio.busSolo = this;
this._soloNode.gain.value = 1;
const otherBuses = GodotAudio.buses.filter((otherBus) => otherBus !== this);
for (let i = 0; i < otherBuses.length; i++) {
const otherBus = otherBuses[i];
otherBus._soloNode.gain.value = 0;
}
}
/**
* Process to disable solo.
* @returns {void}
*/
_disableSolo() {
this.isSolo = false;
GodotAudio.busSolo = null;
this._soloNode.gain.value = 1;
const otherBuses = GodotAudio.buses.filter((otherBus) => otherBus !== this);
for (let i = 0; i < otherBuses.length; i++) {
const otherBus = otherBuses[i];
otherBus._soloNode.gain.value = 1;
}
}
}
const _GodotAudio = {
$GodotAudio__deps: ["$GodotRuntime", "$GodotOS"],
$GodotAudio: {
/**
* Max number of volume channels.
*/
MAX_VOLUME_CHANNELS: 8,
/**
* Represents the index of each sound channel relative to the engine.
*/
GodotChannel: Object.freeze({
CHANNEL_L: 0,
CHANNEL_R: 1,
CHANNEL_C: 3,
CHANNEL_LFE: 4,
CHANNEL_RL: 5,
CHANNEL_RR: 6,
CHANNEL_SL: 7,
CHANNEL_SR: 8,
}),
/**
* Represents the index of each sound channel relative to the Web Audio API.
*/
WebChannel: Object.freeze({
CHANNEL_L: 0,
CHANNEL_R: 1,
CHANNEL_SL: 2,
CHANNEL_SR: 3,
CHANNEL_C: 4,
CHANNEL_LFE: 5,
}),
// `Sample` class
/**
* Registry of `Sample`s.
* @type {Map<string, Sample>}
*/
samples: null,
Sample,
// `SampleNodeBus` class
SampleNodeBus,
// `SampleNode` class
/**
* Registry of `SampleNode`s.
* @type {Map<string, SampleNode>}
*/
sampleNodes: null,
SampleNode,
deleteSampleNode: (pSampleNodeId) => {
GodotAudio.sampleNodes.delete(pSampleNodeId);
if (GodotAudio.sampleFinishedCallback == null) {
return;
}
const sampleNodeIdPtr = GodotRuntime.allocString(pSampleNodeId);
GodotAudio.sampleFinishedCallback(sampleNodeIdPtr);
GodotRuntime.free(sampleNodeIdPtr);
},
// `Bus` class
/**
* Registry of `Bus`es.
* @type {Array<Bus>}
*/
buses: null,
/**
* Reference to the current bus in solo mode.
* @type {Bus | null}
*/
busSolo: null,
Bus,
/**
* Callback to signal that a sample has finished.
* @type {(playbackObjectIdPtr: number) => void | null}
*/
sampleFinishedCallback: null,
/** @type {AudioContext} */
ctx: null,
input: null,
driver: null,
interval: 0,
/** @type {Promise} */
audioPositionWorkletPromise: null,
/** @type {Array<AudioWorkletNode>} */
audioPositionWorkletNodes: null,
/**
* Converts linear volume to Db.
* @param {number} linear Linear value to convert.
* @returns {number}
*/
linear_to_db: function (linear) {
// eslint-disable-next-line no-loss-of-precision
return Math.log(linear) * 8.6858896380650365530225783783321;
},
/**
* Converts Db volume to linear.
* @param {number} db Db value to convert.
* @returns {number}
*/
db_to_linear: function (db) {
// eslint-disable-next-line no-loss-of-precision
return Math.exp(db * 0.11512925464970228420089957273422);
},
init: function (mix_rate, latency, onstatechange, onlatencyupdate) {
// Initialize classes static values.
GodotAudio.samples = new Map();
GodotAudio.sampleNodes = new Map();
GodotAudio.buses = [];
GodotAudio.busSolo = null;
GodotAudio.audioPositionWorkletNodes = [];
const opts = {};
// If mix_rate is 0, let the browser choose.
if (mix_rate) {
GodotAudio.sampleRate = mix_rate;
opts["sampleRate"] = mix_rate;
}
// Do not specify, leave 'interactive' for good performance.
// opts['latencyHint'] = latency / 1000;
const ctx = GODOTSDK.audio.WEBAudio.audioContext;
GodotAudio.ctx = ctx;
ctx.onstatechange = function () {
let state = 0;
switch (ctx.state) {
case "suspended":
state = 0;
break;
case "running":
state = 1;
break;
case "closed":
state = 2;
break;
default:
// Do nothing.
}
onstatechange(state);
};
ctx.onstatechange(); // Immediately notify state.
// Update computed latency
GodotAudio.interval = setInterval(function () {
let computed_latency = 0;
if (ctx.baseLatency) {
computed_latency += GodotAudio.ctx.baseLatency;
}
if (ctx.outputLatency) {
computed_latency += GodotAudio.ctx.outputLatency;
}
onlatencyupdate(computed_latency);
}, 1000);
GodotOS.atexit(GodotAudio.close_async);
// const path = GodotConfig.locate_file('godot.audio.position.worklet.js');
// GodotAudio.audioPositionWorkletPromise = ctx.audioWorklet.addModule(path);
// Initialize WeChat audio adapter
GodotAudio.WX.init();
return ctx.destination.channelCount;
},
create_input: function (callback) {
if (GodotAudio.input) {
return 0; // Already started.
}
function gotMediaInput(stream) {
try {
GodotAudio.input = GodotAudio.ctx.createMediaStreamSource(stream);
callback(GodotAudio.input);
} catch (e) {
GodotRuntime.error("Failed creating input.", e);
}
}
if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) {
navigator.mediaDevices
.getUserMedia({
audio: true,
})
.then(gotMediaInput, function (e) {
GodotRuntime.error("Error getting user media.", e);
});
} else {
if (!navigator.getUserMedia) {
navigator.getUserMedia = navigator.webkitGetUserMedia || navigator.mozGetUserMedia;
}
if (!navigator.getUserMedia) {
GodotRuntime.error("getUserMedia not available.");
return 1;
}
navigator.getUserMedia(
{
audio: true,
},
gotMediaInput,
function (e) {
GodotRuntime.print(e);
}
);
}
return 0;
},
close_async: function (resolve, reject) {
const ctx = GodotAudio.ctx;
GodotAudio.ctx = null;
// Audio was not initialized.
if (!ctx) {
resolve();
return;
}
// Remove latency callback
if (GodotAudio.interval) {
clearInterval(GodotAudio.interval);
GodotAudio.interval = 0;
}
// Disconnect input, if it was started.
if (GodotAudio.input) {
GodotAudio.input.disconnect();
GodotAudio.input = null;
}
// Disconnect output
let closed = Promise.resolve();
if (GodotAudio.driver) {
closed = GodotAudio.driver.close();
}
closed
.then(function () {
return ctx.close();
})
.then(function () {
ctx.onstatechange = null;
resolve();
})
.catch(function (e) {
ctx.onstatechange = null;
GodotRuntime.error("Error closing AudioContext", e);
resolve();
});
},
/**
* WeChat Mini Game Audio Adapter
* Uses InnerAudioContext API for native audio playback
*/
WX: {
DEBUG: false,
MAX_POOL_SIZE: 16,
DEFAULT_CACHE_LIMIT_BYTES: 8 * 1024 * 1024,
DEFAULT_NATIVE_MIN_DURATION_SECONDS: 3,
nativeStreams: null,
activePlaybacks: null,
contextPool: null,
busVolumes: null,
busMutes: null,
subpackageLoads: null,
manifest: null,
fs: null,
cacheDir: "",
cacheIndexPath: "",
cacheRecords: null,
cacheRefs: null,
cacheLocks: null,
invalidCacheHashes: null,
cacheHashStreams: null,
cacheBytes: 0,
cacheLimitBytes: 0,
tempCounter: 0,
getRoot: function () {
if (typeof GameGlobal !== "undefined") {
return GameGlobal;
}
if (typeof globalThis !== "undefined") {
return globalThis;
}
return {};
},
init: function () {
if (typeof wx === "undefined") {
return;
}
const configuredLimit = Number(
GodotAudio.WX.getRoot().__godotMinigameNativeAudioCacheLimitBytes
);
GodotAudio.WX.cacheLimitBytes =
Number.isFinite(configuredLimit) && configuredLimit > 0
? Math.floor(configuredLimit)
: GodotAudio.WX.DEFAULT_CACHE_LIMIT_BYTES;
GodotAudio.WX.nativeStreams = new Map();
GodotAudio.WX.activePlaybacks = new Map();
GodotAudio.WX.contextPool = [];
GodotAudio.WX.busVolumes = new Map();
GodotAudio.WX.busMutes = new Map();
GodotAudio.WX.subpackageLoads = new Map();
GodotAudio.WX.cacheRecords = new Map();
GodotAudio.WX.cacheRefs = new Map();
GodotAudio.WX.cacheLocks = new Set();
GodotAudio.WX.invalidCacheHashes = new Set();
GodotAudio.WX.cacheHashStreams = new Map();
GodotAudio.WX.cacheBytes = 0;
GodotAudio.WX.tempCounter = 0;
GodotAudio.WX.fs = wx.getFileSystemManager();
GodotAudio.WX.cacheDir = `${wx.env.USER_DATA_PATH}/godot_native_audio`;
GodotAudio.WX.cacheIndexPath = `${GodotAudio.WX.cacheDir}/index.json`;
GodotAudio.WX.manifest =
GodotAudio.WX.getRoot().__godotMinigameNativeAudioManifest || {};
GodotAudio.WX.initializeCache();
GodotAudio.WX.cleanupLegacyAudioFiles();
GodotAudio.WX.getRoot().GodotAudioDebug = {
setDebug: (enabled) => {
GodotAudio.WX.DEBUG = Boolean(enabled);
},
getStats: () => ({
streams: GodotAudio.WX.nativeStreams.size,
activePlaybacks: GodotAudio.WX.activePlaybacks.size,
pooledContexts: GodotAudio.WX.contextPool.length,
cacheBytes: GodotAudio.WX.cacheBytes,
cacheLimitBytes: GodotAudio.WX.cacheLimitBytes,
cacheEntries: GodotAudio.WX.cacheRecords.size,
}),
listStreams: () => Array.from(GodotAudio.WX.nativeStreams.entries()),
listCache: () => Array.from(GodotAudio.WX.cacheRecords.values()),
};
},
log: function (message) {
if (GodotAudio.WX.DEBUG) {
console.log(`[GodotAudioWX] ${message}`);
}
},
error: function (message, error) {
console.error(`[GodotAudioWX] ${message}`, error || "");
},
getNativeMinDuration: function () {
const configured = Number(
GodotAudio.WX.getRoot().__godotMinigameNativeAudioMinDurationSeconds
);
return Number.isFinite(configured) && configured >= 0
? configured
: GodotAudio.WX.DEFAULT_NATIVE_MIN_DURATION_SECONDS;
},
fileExists: function (path) {
try {
GodotAudio.WX.fs.statSync(path);
return true;
} catch (e) {
return false;
}
},
directoryExists: function (path) {
try {
const stat = GodotAudio.WX.fs.statSync(path);
return typeof stat.isDirectory !== "function" || stat.isDirectory();
} catch (e) {
return false;
}
},
safeUnlink: function (path) {
try {
if (GodotAudio.WX.fileExists(path)) {
GodotAudio.WX.fs.unlinkSync(path);
}
} catch (e) {
GodotAudio.WX.error(`Failed to remove ${path}`, e);
}
},
cleanupLegacyAudioFiles: function () {
try {
GodotAudio.WX.fs.readdirSync(wx.env.USER_DATA_PATH).forEach((file) => {
if (file.startsWith("godot_audio_") && file.endsWith(".wav")) {
GodotAudio.WX.safeUnlink(`${wx.env.USER_DATA_PATH}/${file}`);
}
});
} catch (e) {
GodotAudio.WX.error("Failed to clean legacy audio files", e);
}
},
initializeCache: function () {
if (!GodotAudio.WX.directoryExists(GodotAudio.WX.cacheDir)) {
try {
GodotAudio.WX.fs.mkdirSync(GodotAudio.WX.cacheDir, true);
} catch (e) {
if (!GodotAudio.WX.directoryExists(GodotAudio.WX.cacheDir)) {
GodotAudio.WX.error("Failed to create native audio cache", e);
return;
}
}
}
const backupPath = `${GodotAudio.WX.cacheIndexPath}.bak`;
if (
!GodotAudio.WX.fileExists(GodotAudio.WX.cacheIndexPath) &&
GodotAudio.WX.fileExists(backupPath)
) {
try {
GodotAudio.WX.fs.renameSync(backupPath, GodotAudio.WX.cacheIndexPath);
} catch (e) {
GodotAudio.WX.error("Failed to restore audio cache index", e);
}
}
let indexedEntries = {};
try {
if (GodotAudio.WX.fileExists(GodotAudio.WX.cacheIndexPath)) {
const parsed = JSON.parse(
GodotAudio.WX.fs.readFileSync(GodotAudio.WX.cacheIndexPath, "utf8")
);
indexedEntries =
parsed && parsed.entries && typeof parsed.entries === "object"
? parsed.entries
: {};
}
} catch (e) {
GodotAudio.WX.error("Audio cache index is invalid; rebuilding it", e);
}
let files = [];
try {
files = GodotAudio.WX.fs.readdirSync(GodotAudio.WX.cacheDir);
} catch (e) {
GodotAudio.WX.error("Failed to list native audio cache", e);
}
const liveFiles = new Set();
files.forEach((file) => {
if (file.endsWith(".tmp") || file === "index.json.bak") {
GodotAudio.WX.safeUnlink(`${GodotAudio.WX.cacheDir}/${file}`);
} else if (file !== "index.json") {
liveFiles.add(file);
}
});
Object.keys(indexedEntries).forEach((hash) => {
const entry = indexedEntries[hash];
if (!/^[0-9a-f]{64}$/.test(hash) || !entry || typeof entry.file !== "string") {
return;
}
const path = `${GodotAudio.WX.cacheDir}/${entry.file}`;
if (!liveFiles.has(entry.file)) {
return;
}
try {
const stat = GodotAudio.WX.fs.statSync(path);
if (Number(entry.size) !== Number(stat.size)) {
GodotAudio.WX.safeUnlink(path);
liveFiles.delete(entry.file);
return;
}
const codec = entry.file.includes(".") ? entry.file.split(".").pop() : "bin";
GodotAudio.WX.cacheRecords.set(hash, {
hash,
file: entry.file,
path,
size: Number(stat.size),
lastAccess: Number(entry.lastAccess) || 0,
codec: String(entry.codec || codec),
});
GodotAudio.WX.cacheBytes += Number(stat.size);
liveFiles.delete(entry.file);
} catch (e) {
GodotAudio.WX.safeUnlink(path);
}
});
liveFiles.forEach((file) => {
const match = /^([0-9a-f]{64})\.([a-z0-9]+)$/.exec(file);
const path = `${GodotAudio.WX.cacheDir}/${file}`;
if (!match) {
GodotAudio.WX.safeUnlink(path);
return;
}
try {
const stat = GodotAudio.WX.fs.statSync(path);
GodotAudio.WX.cacheRecords.set(match[1], {
hash: match[1],
file,
path,
size: Number(stat.size),
lastAccess: 0,
codec: match[2],
});
GodotAudio.WX.cacheBytes += Number(stat.size);
} catch (e) {
GodotAudio.WX.safeUnlink(path);
}
});
GodotAudio.WX.evictFor(0, "");
GodotAudio.WX.persistCacheIndex();
},
persistCacheIndex: function () {
const entries = {};
GodotAudio.WX.cacheRecords.forEach((entry, hash) => {
entries[hash] = {
file: entry.file,
size: entry.size,
lastAccess: entry.lastAccess,
codec: entry.codec,
};
});
const tempPath = `${GodotAudio.WX.cacheIndexPath}.${Date.now()}.${GodotAudio.WX.tempCounter++}.tmp`;
const backupPath = `${GodotAudio.WX.cacheIndexPath}.bak`;
try {
GodotAudio.WX.fs.writeFileSync(
tempPath,
JSON.stringify({ version: 1, entries }),
"utf8"
);
GodotAudio.WX.safeUnlink(backupPath);
if (GodotAudio.WX.fileExists(GodotAudio.WX.cacheIndexPath)) {
GodotAudio.WX.fs.renameSync(GodotAudio.WX.cacheIndexPath, backupPath);
}
GodotAudio.WX.fs.renameSync(tempPath, GodotAudio.WX.cacheIndexPath);
GodotAudio.WX.safeUnlink(backupPath);
} catch (e) {
GodotAudio.WX.safeUnlink(tempPath);
if (
!GodotAudio.WX.fileExists(GodotAudio.WX.cacheIndexPath) &&
GodotAudio.WX.fileExists(backupPath)
) {
try {
GodotAudio.WX.fs.renameSync(backupPath, GodotAudio.WX.cacheIndexPath);
} catch (restoreError) {
GodotAudio.WX.error("Failed to restore audio cache index", restoreError);
}
}
GodotAudio.WX.error("Failed to persist audio cache index", e);
}
},
removeCacheRecord: function (hash) {
const entry = GodotAudio.WX.cacheRecords.get(hash);
if (!entry) {
GodotAudio.WX.invalidCacheHashes.delete(hash);
return;
}
GodotAudio.WX.safeUnlink(entry.path);
GodotAudio.WX.cacheRecords.delete(hash);
GodotAudio.WX.invalidCacheHashes.delete(hash);
GodotAudio.WX.cacheBytes = Math.max(0, GodotAudio.WX.cacheBytes - entry.size);
const streamIds = GodotAudio.WX.cacheHashStreams.get(hash);
if (streamIds) {
streamIds.forEach((streamId) => GodotAudio.WX.nativeStreams.delete(streamId));
GodotAudio.WX.cacheHashStreams.delete(hash);
}
},
invalidateCacheRecord: function (hash) {
if (!GodotAudio.WX.cacheRecords.has(hash)) {
GodotAudio.WX.invalidCacheHashes.delete(hash);
return;
}
if ((GodotAudio.WX.cacheRefs.get(hash) || 0) > 0) {
GodotAudio.WX.invalidCacheHashes.add(hash);
return;
}
GodotAudio.WX.removeCacheRecord(hash);
GodotAudio.WX.persistCacheIndex();
},
evictFor: function (incomingSize, protectedHash) {
if (incomingSize > GodotAudio.WX.cacheLimitBytes) {
return false;
}
const candidates = Array.from(GodotAudio.WX.cacheRecords.values())
.filter(
(entry) =>
entry.hash !== protectedHash &&
(GodotAudio.WX.cacheRefs.get(entry.hash) || 0) === 0 &&
!GodotAudio.WX.cacheLocks.has(entry.hash)
)
.sort((a, b) => a.lastAccess - b.lastAccess);
for (const entry of candidates) {
if (GodotAudio.WX.cacheBytes + incomingSize <= GodotAudio.WX.cacheLimitBytes) {
break;
}
GodotAudio.WX.removeCacheRecord(entry.hash);
}
return GodotAudio.WX.cacheBytes + incomingSize <= GodotAudio.WX.cacheLimitBytes;
},
materializeCacheFile: function (hash, codec, data) {
const existing = GodotAudio.WX.cacheRecords.get(hash);
if (
existing &&
!GodotAudio.WX.invalidCacheHashes.has(hash) &&
GodotAudio.WX.fileExists(existing.path)
) {
existing.lastAccess = Date.now();
GodotAudio.WX.persistCacheIndex();
return existing.path;
}
if (existing) {
GodotAudio.WX.invalidateCacheRecord(hash);
if (GodotAudio.WX.cacheRecords.has(hash)) {
return "";
}
}
const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
if (!GodotAudio.WX.evictFor(bytes.byteLength, hash)) {
GodotAudio.WX.error(
`Native audio needs ${bytes.byteLength} bytes, exceeding the ${GodotAudio.WX.cacheLimitBytes}-byte cache limit. Increase it explicitly or export this file into a package.`
);
return "";
}
const safeCodec = String(codec || "bin")
.toLowerCase()
.replace(/[^a-z0-9]/g, "");
const file = `${hash}.${safeCodec}`;
const targetPath = `${GodotAudio.WX.cacheDir}/${file}`;
const tempPath = `${GodotAudio.WX.cacheDir}/.${hash}.${Date.now()}.${GodotAudio.WX.tempCounter++}.tmp`;
GodotAudio.WX.cacheLocks.add(hash);
try {
const buffer = bytes.buffer.slice(
bytes.byteOffset,
bytes.byteOffset + bytes.byteLength
);
GodotAudio.WX.fs.writeFileSync(tempPath, buffer, "binary");
const stat = GodotAudio.WX.fs.statSync(tempPath);
if (Number(stat.size) !== bytes.byteLength) {
throw new Error(`short write: expected ${bytes.byteLength}, got ${stat.size}`);
}
if (GodotAudio.WX.fileExists(targetPath)) {
GodotAudio.WX.safeUnlink(tempPath);
} else {
GodotAudio.WX.fs.renameSync(tempPath, targetPath);
}
const targetStat = GodotAudio.WX.fs.statSync(targetPath);
const entry = {
hash,
file,
path: targetPath,
size: Number(targetStat.size),
lastAccess: Date.now(),
codec: safeCodec,
};
GodotAudio.WX.cacheRecords.set(hash, entry);
GodotAudio.WX.cacheBytes += entry.size;
GodotAudio.WX.persistCacheIndex();
return targetPath;
} catch (e) {
GodotAudio.WX.safeUnlink(tempPath);
GodotAudio.WX.error(`Failed to cache native audio ${hash}`, e);
return "";
} finally {
GodotAudio.WX.cacheLocks.delete(hash);
}
},
trackCacheStream: function (hash, streamObjectId) {
let streamIds = GodotAudio.WX.cacheHashStreams.get(hash);
if (!streamIds) {
streamIds = new Set();
GodotAudio.WX.cacheHashStreams.set(hash, streamIds);
}
streamIds.add(streamObjectId);
},
acquireCache: function (hash) {
const entry = GodotAudio.WX.cacheRecords.get(hash);
if (!entry || !GodotAudio.WX.fileExists(entry.path)) {
GodotAudio.WX.removeCacheRecord(hash);
GodotAudio.WX.persistCacheIndex();
return false;
}
if (GodotAudio.WX.invalidCacheHashes.has(hash)) {
GodotAudio.WX.invalidateCacheRecord(hash);
return false;
}
GodotAudio.WX.cacheRefs.set(hash, (GodotAudio.WX.cacheRefs.get(hash) || 0) + 1);
entry.lastAccess = Date.now();
GodotAudio.WX.persistCacheIndex();
return true;
},
releaseCache: function (hash) {
const refs = GodotAudio.WX.cacheRefs.get(hash) || 0;
if (refs <= 1) {
GodotAudio.WX.cacheRefs.delete(hash);
if (GodotAudio.WX.invalidCacheHashes.has(hash)) {
GodotAudio.WX.removeCacheRecord(hash);
GodotAudio.WX.persistCacheIndex();
}
} else {
GodotAudio.WX.cacheRefs.set(hash, refs - 1);
}
},
resolveManifestAsset: function (sourcePath, sourceUid, contentHash) {
const manifest = GodotAudio.WX.manifest || {};
const aliases =
manifest.aliases && typeof manifest.aliases === "object" ? manifest.aliases : {};
const assets =
manifest.assets && typeof manifest.assets === "object" ? manifest.assets : {};
const candidates = [contentHash, aliases[sourceUid], aliases[sourcePath]].filter(Boolean);
for (const hash of candidates) {
const asset = assets[hash];
if (asset && typeof asset.src === "string" && asset.src.length > 0) {
return {
kind: "package",
hash,
path: asset.src,
subpackage: String(asset.subpackage || ""),
codec: String(asset.codec || ""),
};
}
}
return null;
},
encodeWAV: function (leftChannel, rightChannel, sampleRate) {
const length = leftChannel.length + rightChannel.length;
const buffer = new ArrayBuffer(44 + length * 2);
const view = new DataView(buffer);
const writeString = (offset, value) => {
for (let i = 0; i < value.length; i++) {
view.setUint8(offset + i, value.charCodeAt(i));
}
};
writeString(0, "RIFF");
view.setUint32(4, 36 + length * 2, true);
writeString(8, "WAVE");
writeString(12, "fmt ");
view.setUint32(16, 16, true);
view.setUint16(20, 1, true);
view.setUint16(22, 2, true);
view.setUint32(24, sampleRate, true);
view.setUint32(28, sampleRate * 4, true);
view.setUint16(32, 4, true);
view.setUint16(34, 16, true);
writeString(36, "data");
view.setUint32(40, length * 2, true);
let offset = 44;
for (let i = 0; i < leftChannel.length; i++) {
view.setInt16(offset, Math.max(-1, Math.min(1, leftChannel[i])) * 0x7fff, true);
offset += 2;
view.setInt16(offset, Math.max(-1, Math.min(1, rightChannel[i])) * 0x7fff, true);
offset += 2;
}
return buffer;
},
registerNativeStream: function (
streamObjectId,
sourcePath,
sourceUid,
contentHash,
dataPtr,
dataSize,
codec,
loopMode,
framesTotal,
sampleRate
) {
if (GodotAudio.WX.nativeStreams.has(streamObjectId)) {
return;
}
const packaged = GodotAudio.WX.resolveManifestAsset(
sourcePath,
sourceUid,
contentHash
);
if (packaged) {
packaged.loopMode = loopMode;
GodotAudio.WX.nativeStreams.set(streamObjectId, packaged);
return;
}
if (!dataPtr || dataSize <= 0 || !/^[0-9a-f]{64}$/.test(contentHash)) {
GodotAudio.WX.error(
`No packaged source or valid cache content for ${sourceUid || sourcePath || streamObjectId}`
);
return;
}
let audioBytes;
let outputCodec = String(codec || "").toLowerCase();
if (outputCodec === "pcm_f32_planar") {
const expectedWavSize = 44 + framesTotal * 4;
if (expectedWavSize > GodotAudio.WX.cacheLimitBytes) {
GodotAudio.WX.error(
`Decoded WAV fallback needs ${expectedWavSize} bytes, exceeding the ${GodotAudio.WX.cacheLimitBytes}-byte native audio cache limit. Export this audio into a package or increase the limit explicitly.`
);
return;
}
const left = new Float32Array(
GodotRuntime.heapSub(HEAPF32, dataPtr, framesTotal)
);
const right = new Float32Array(
GodotRuntime.heapSub(HEAPF32, dataPtr + framesTotal * 4, framesTotal)
);
audioBytes = new Uint8Array(
GodotAudio.WX.encodeWAV(left, right, sampleRate)
);
outputCodec = "wav";
} else {
audioBytes = new Uint8Array(
GodotRuntime.heapSlice(HEAPU8, dataPtr, dataSize)
);
}
const path = GodotAudio.WX.materializeCacheFile(
contentHash,
outputCodec,
audioBytes
);
if (!path) {
return;
}
GodotAudio.WX.nativeStreams.set(streamObjectId, {
kind: "cache",
hash: contentHash,
path,
codec: outputCodec,
loopMode,
});
GodotAudio.WX.trackCacheStream(contentHash, streamObjectId);
},
isStreamRegistered: function (streamObjectId) {
const streamInfo =
GodotAudio.WX.nativeStreams && GodotAudio.WX.nativeStreams.get(streamObjectId);
if (!streamInfo) {
return false;
}
if (streamInfo.kind === "cache" && !GodotAudio.WX.fileExists(streamInfo.path)) {
GodotAudio.WX.nativeStreams.delete(streamObjectId);
return false;
}
return true;
},
unregisterStream: function (streamObjectId) {
const streamInfo =
GodotAudio.WX.nativeStreams && GodotAudio.WX.nativeStreams.get(streamObjectId);
if (!streamInfo) {
return false;
}
GodotAudio.WX.nativeStreams.delete(streamObjectId);
if (streamInfo.kind === "cache") {
const streamIds = GodotAudio.WX.cacheHashStreams.get(streamInfo.hash);
if (streamIds) {
streamIds.delete(streamObjectId);
if (streamIds.size === 0) {
GodotAudio.WX.cacheHashStreams.delete(streamInfo.hash);
}
}
}
return true;
},
ensureSubpackage: function (name) {
if (!name) {
return Promise.resolve();
}
const existing = GodotAudio.WX.subpackageLoads.get(name);
if (existing) {
return existing;
}
const loading = new Promise((resolve, reject) => {
if (typeof wx.loadSubpackage !== "function") {
reject(new Error("wx.loadSubpackage is unavailable"));
return;
}
wx.loadSubpackage({ name, success: resolve, fail: reject });
});
GodotAudio.WX.subpackageLoads.set(name, loading);
loading.catch(() => GodotAudio.WX.subpackageLoads.delete(name));
return loading;
},
dbToLinear: function (db) {
return Math.exp(db * 0.11512925464970228);
},
calculateFinalVolume: function (baseVolume, busIndex) {
if (GodotAudio.WX.busMutes.get(busIndex) || false) {
return 0;
}
const busVolumeDb = GodotAudio.WX.busVolumes.get(busIndex) || 0;
return Math.max(
0,
Math.min(1, baseVolume * GodotAudio.WX.dbToLinear(busVolumeDb))
);
},
getContext: function (desiredSrc) {
if (desiredSrc) {
const matchingIndex = GodotAudio.WX.contextPool.findIndex(
(ctx) => ctx.src === desiredSrc
);
if (matchingIndex !== -1) {
const ctx = GodotAudio.WX.contextPool[matchingIndex];
GodotAudio.WX.contextPool.splice(matchingIndex, 1);
return ctx;
}
}
return wx.createInnerAudioContext();
},
resetContext: function (ctx) {
ctx.offCanplay();
ctx.offPlay();
ctx.offPause();
ctx.offStop();
ctx.offEnded();
ctx.offTimeUpdate();
ctx.offError();
ctx.offWaiting();
ctx.offSeeking();
ctx.offSeeked();
ctx.autoplay = false;
ctx.loop = false;
ctx.volume = 1;
ctx.playbackRate = 1;
ctx.startTime = 0;
},
destroyContext: function (ctx) {
if (!ctx) {
return;
}
try {
GodotAudio.WX.resetContext(ctx);
ctx.stop();
} catch (e) {
// Ignore teardown errors from already released contexts.
}
if (typeof ctx.destroy === "function") {
ctx.destroy();
}
},
releaseContext: function (ctx) {
if (!ctx) {
return;
}
GodotAudio.WX.resetContext(ctx);
if (GodotAudio.WX.contextPool.length >= GodotAudio.WX.MAX_POOL_SIZE) {
GodotAudio.WX.destroyContext(ctx);
return;
}
GodotAudio.WX.contextPool.push(ctx);
},
notifyFinished: function (playbackObjectId) {
if (!GodotAudio.sampleFinishedCallback) {
return;
}
const playbackIdPtr = GodotRuntime.allocString(playbackObjectId);
GodotAudio.sampleFinishedCallback(playbackIdPtr);
GodotRuntime.free(playbackIdPtr);
},
cleanupPlayback: function (playbackObjectId, ctx, destroy) {
const playback = GodotAudio.WX.activePlaybacks.get(playbackObjectId);
if (!playback || (ctx && playback.ctx !== ctx)) {
return false;
}
GodotAudio.WX.activePlaybacks.delete(playbackObjectId);
playback.cancelled = true;
if (playback.hashRef) {
GodotAudio.WX.releaseCache(playback.streamInfo.hash);
playback.hashRef = false;
}
if (playback.ctx) {
if (destroy) {
GodotAudio.WX.destroyContext(playback.ctx);
} else {
GodotAudio.WX.releaseContext(playback.ctx);
}
}
return true;
},
startSample: function (
playbackObjectId,
streamObjectId,
busIndex,
offset,
pitchScale,
volumePtr
) {
const streamInfo = GodotAudio.WX.nativeStreams.get(streamObjectId);
if (!streamInfo) {
GodotAudio.WX.error(`Native stream ${streamObjectId} is not registered`);
return;
}
GodotAudio.WX.stopSample(playbackObjectId);
const volume = GodotRuntime.heapSub(HEAPF32, volumePtr, 8);
const playback = {
ctx: null,
streamInfo,
busIndex,
baseVolume: Math.max(volume[0], volume[1]),
cancelled: false,
hashRef: false,
};
if (streamInfo.kind === "cache") {
if (!GodotAudio.WX.acquireCache(streamInfo.hash)) {
GodotAudio.WX.notifyFinished(playbackObjectId);
return;
}
playback.hashRef = true;
}
GodotAudio.WX.activePlaybacks.set(playbackObjectId, playback);
const beginPlayback = () => {
if (
playback.cancelled ||
GodotAudio.WX.activePlaybacks.get(playbackObjectId) !== playback
) {
return;
}
const ctx = GodotAudio.WX.getContext(streamInfo.path);
playback.ctx = ctx;
GodotAudio.WX.resetContext(ctx);
if (ctx.src !== streamInfo.path) {
ctx.src = streamInfo.path;
}
ctx.volume = GodotAudio.WX.calculateFinalVolume(
playback.baseVolume,
busIndex
);
ctx.playbackRate = Math.max(0.5, Math.min(2, pitchScale));
ctx.loop = streamInfo.loopMode === "forward";
ctx.startTime = offset > 0 ? offset : 0;
ctx.onEnded(() => {
if (GodotAudio.WX.cleanupPlayback(playbackObjectId, ctx, false)) {
GodotAudio.WX.notifyFinished(playbackObjectId);
}
});
ctx.onStop(() => {
if (GodotAudio.WX.cleanupPlayback(playbackObjectId, ctx, false)) {
GodotAudio.WX.notifyFinished(playbackObjectId);
}
});
ctx.onError((error) => {
GodotAudio.WX.error(`Playback error for ${playbackObjectId}`, error);
const cleaned = GodotAudio.WX.cleanupPlayback(playbackObjectId, ctx, true);
if (cleaned && streamInfo.kind === "cache") {
GodotAudio.WX.invalidateCacheRecord(streamInfo.hash);
}
if (cleaned) {
GodotAudio.WX.notifyFinished(playbackObjectId);
}
});
try {
ctx.play();
} catch (error) {
GodotAudio.WX.error(`Playback start failed for ${playbackObjectId}`, error);
const cleaned = GodotAudio.WX.cleanupPlayback(playbackObjectId, ctx, true);
if (cleaned && streamInfo.kind === "cache") {
GodotAudio.WX.invalidateCacheRecord(streamInfo.hash);
}
if (cleaned) {
GodotAudio.WX.notifyFinished(playbackObjectId);
}
}
};
GodotAudio.WX.ensureSubpackage(streamInfo.subpackage)
.then(beginPlayback)
.catch((error) => {
GodotAudio.WX.error(
`Failed to load audio subpackage ${streamInfo.subpackage}`,
error
);
if (GodotAudio.WX.cleanupPlayback(playbackObjectId, null, false)) {
GodotAudio.WX.notifyFinished(playbackObjectId);
}
});
},
stopSample: function (playbackObjectId) {
const playback = GodotAudio.WX.activePlaybacks.get(playbackObjectId);
if (!playback) {
return false;
}
GodotAudio.WX.activePlaybacks.delete(playbackObjectId);
playback.cancelled = true;
if (playback.hashRef) {
GodotAudio.WX.releaseCache(playback.streamInfo.hash);
playback.hashRef = false;
}
if (playback.ctx) {
playback.ctx.stop();
GodotAudio.WX.releaseContext(playback.ctx);
}
return true;
},
setPause: function (playbackObjectId, paused) {
const playback = GodotAudio.WX.activePlaybacks.get(playbackObjectId);
if (!playback) {
return false;
}
if (playback.ctx) {
if (paused) {
playback.ctx.pause();
} else {
playback.ctx.play();
}
}
return true;
},
isActive: function (playbackObjectId) {
return GodotAudio.WX.activePlaybacks.has(playbackObjectId);
},
getPosition: function (playbackObjectId) {
const playback = GodotAudio.WX.activePlaybacks.get(playbackObjectId);
return playback && playback.ctx ? playback.ctx.currentTime : 0;
},
updatePitchScale: function (playbackObjectId, pitchScale) {
const playback = GodotAudio.WX.activePlaybacks.get(playbackObjectId);
if (!playback) {
return false;
}
if (playback.ctx) {
playback.ctx.playbackRate = Math.max(0.5, Math.min(2, pitchScale));
}
return true;
},
updateVolume: function (playbackObjectId, volumePtr) {
const playback = GodotAudio.WX.activePlaybacks.get(playbackObjectId);
if (!playback) {
return false;
}
const volume = GodotRuntime.heapSub(HEAPF32, volumePtr, 8);
playback.baseVolume = Math.max(volume[0], volume[1]);
if (playback.ctx) {
playback.ctx.volume = GodotAudio.WX.calculateFinalVolume(
playback.baseVolume,
playback.busIndex
);
}
return true;
},
setBusVolume: function (busIndex, volumeDb) {
GodotAudio.WX.busVolumes.set(busIndex, volumeDb);
GodotAudio.WX.activePlaybacks.forEach((playback) => {
if (playback.busIndex === busIndex && playback.ctx) {
playback.ctx.volume = GodotAudio.WX.calculateFinalVolume(
playback.baseVolume,
busIndex
);
}
});
},
setBusMute: function (busIndex, enabled) {
GodotAudio.WX.busMutes.set(busIndex, enabled);
GodotAudio.WX.activePlaybacks.forEach((playback) => {
if (playback.busIndex === busIndex && playback.ctx) {
playback.ctx.volume = GodotAudio.WX.calculateFinalVolume(
playback.baseVolume,
busIndex
);
}
});
},
},
/**
* Triggered when a sample node needs to start.
* @param {string} playbackObjectId The unique id of the sample playback
* @param {string} streamObjectId The unique id of the stream
* @param {number} busIndex Index of the bus currently binded to the sample playback
* @param {SampleNodeOptions | undefined} startOptions Optional params.
* @returns {void}
*/
start_sample: function (playbackObjectId, streamObjectId, busIndex, startOptions) {
GodotAudio.SampleNode.stopSampleNode(playbackObjectId);
GodotAudio.SampleNode.create(
{
busIndex,
id: playbackObjectId,
streamObjectId,
},
startOptions
);
},
/**
* Triggered when a sample node needs to be stopped.
* @param {string} playbackObjectId Id of the sample playback
* @returns {void}
*/
stop_sample: function (playbackObjectId) {
GodotAudio.SampleNode.stopSampleNode(playbackObjectId);
},
/**
* Triggered when a sample node needs to be paused or unpaused.
* @param {string} playbackObjectId Id of the sample playback
* @param {boolean} pause State of the pause
* @returns {void}
*/
sample_set_pause: function (playbackObjectId, pause) {
GodotAudio.SampleNode.pauseSampleNode(playbackObjectId, pause);
},
/**
* Triggered when a sample node needs its pitch scale to be updated.
* @param {string} playbackObjectId Id of the sample playback
* @param {number} pitchScale Pitch scale of the sample playback
* @returns {void}
*/
update_sample_pitch_scale: function (playbackObjectId, pitchScale) {
const sampleNode = GodotAudio.SampleNode.getSampleNodeOrNull(playbackObjectId);
if (sampleNode == null) {
return;
}
sampleNode.setPitchScale(pitchScale);
},
/**
* Triggered when a sample node volumes need to be updated.
* @param {string} playbackObjectId Id of the sample playback
* @param {Array<number>} busIndexes Indexes of the buses that need to be updated
* @param {Float32Array} volumes Array of the volumes
* @returns {void}
*/
sample_set_volumes_linear: function (playbackObjectId, busIndexes, volumes) {
const sampleNode = GodotAudio.SampleNode.getSampleNodeOrNull(playbackObjectId);
if (sampleNode == null) {
return;
}
const buses = busIndexes.map((busIndex) => GodotAudio.Bus.getBus(busIndex));
sampleNode.setVolumes(buses, volumes);
},
/**
* Triggered when the bus count changes.
* @param {number} count Number of buses
* @returns {void}
*/
set_sample_bus_count: function (count) {
GodotAudio.Bus.setCount(count);
},
/**
* Triggered when a bus needs to be removed.
* @param {number} index Bus index
* @returns {void}
*/
remove_sample_bus: function (index) {
const bus = GodotAudio.Bus.getBusOrNull(index);
if (bus == null) {
return;
}
bus.clear();
},
/**
* Triggered when a bus needs to be at the desired position.
* @param {number} atPos Position to add the bus
* @returns {void}
*/
add_sample_bus: function (atPos) {
GodotAudio.Bus.addAt(atPos);
},
/**
* Triggered when a bus needs to be moved.
* @param {number} busIndex Index of the bus to move
* @param {number} toPos Index of the new position of the bus
* @returns {void}
*/
move_sample_bus: function (busIndex, toPos) {
GodotAudio.Bus.move(busIndex, toPos);
},
/**
* Triggered when the "send" value of a bus changes.
* @param {number} busIndex Index of the bus to update the "send" value
* @param {number} sendIndex Index of the bus that is the new "send"
* @returns {void}
*/
set_sample_bus_send: function (busIndex, sendIndex) {
const bus = GodotAudio.Bus.getBusOrNull(busIndex);
if (bus == null) {
// Cannot send from an invalid bus.
return;
}
let targetBus = GodotAudio.Bus.getBusOrNull(sendIndex);
if (targetBus == null) {
// Send to master.
targetBus = GodotAudio.Bus.getBus(0);
}
bus.setSend(targetBus);
},
/**
* Triggered when a bus needs its volume db to be updated.
* @param {number} busIndex Index of the bus to update its volume db
* @param {number} volumeDb Volume of the bus
* @returns {void}
*/
set_sample_bus_volume_db: function (busIndex, volumeDb) {
const bus = GodotAudio.Bus.getBusOrNull(busIndex);
if (bus == null) {
return;
}
bus.setVolumeDb(volumeDb);
},
/**
* Triggered when a bus needs to update its solo status
* @param {number} busIndex Index of the bus to update its solo status
* @param {boolean} enable Status of the solo
* @returns {void}
*/
set_sample_bus_solo: function (busIndex, enable) {
const bus = GodotAudio.Bus.getBusOrNull(busIndex);
if (bus == null) {
return;
}
bus.solo(enable);
},
/**
* Triggered when a bus needs to update its mute status
* @param {number} busIndex Index of the bus to update its mute status
* @param {boolean} enable Status of the mute
* @returns {void}
*/
set_sample_bus_mute: function (busIndex, enable) {
const bus = GodotAudio.Bus.getBusOrNull(busIndex);
if (bus == null) {
return;
}
bus.mute(enable);
},
},
godot_audio_is_available__sig: "i",
godot_audio_is_available__proxy: "sync",
godot_audio_is_available: function () {
// if (!(window.AudioContext || window.webkitAudioContext)) {
// return 0;
// }
return 1;
},
godot_audio_has_worklet__proxy: "sync",
godot_audio_has_worklet__sig: "i",
godot_audio_has_worklet: function () {
// WeChat Mini Game does not support AudioWorklet.
return 0;
},
godot_audio_has_script_processor__proxy: "sync",
godot_audio_has_script_processor__sig: "i",
godot_audio_has_script_processor: function () {
// return GodotAudio.ctx && GodotAudio.ctx.createScriptProcessor ? 1 : 0;
return 1;
},
godot_audio_init__proxy: "sync",
godot_audio_init__sig: "iiiii",
godot_audio_init: function (p_mix_rate, p_latency, p_state_change, p_latency_update) {
const statechange = GodotRuntime.get_func(p_state_change);
const latencyupdate = GodotRuntime.get_func(p_latency_update);
const mix_rate = GodotRuntime.getHeapValue(p_mix_rate, "i32");
const channels = GodotAudio.init(mix_rate, p_latency, statechange, latencyupdate);
GodotRuntime.setHeapValue(p_mix_rate, GodotAudio.ctx.sampleRate, "i32");
return channels;
},
godot_audio_resume__proxy: "sync",
godot_audio_resume__sig: "v",
godot_audio_resume: function () {
if (GodotAudio.ctx && GodotAudio.ctx.state !== "running") {
GodotAudio.ctx.resume();
}
},
godot_audio_input_start__proxy: "sync",
godot_audio_input_start__sig: "i",
godot_audio_input_start: function () {
return GodotAudio.create_input(function (input) {
input.connect(GodotAudio.driver.get_node());
});
},
godot_audio_input_stop__proxy: "sync",
godot_audio_input_stop__sig: "v",
godot_audio_input_stop: function () {
if (GodotAudio.input) {
const tracks = GodotAudio.input["mediaStream"]["getTracks"]();
for (let i = 0; i < tracks.length; i++) {
tracks[i]["stop"]();
}
GodotAudio.input.disconnect();
GodotAudio.input = null;
}
},
godot_audio_wechat_is_available__proxy: "sync",
godot_audio_wechat_is_available__sig: "i",
godot_audio_wechat_is_available: function () {
return Number(typeof wx !== "undefined");
},
godot_audio_wechat_get_native_audio_min_duration__proxy: "sync",
godot_audio_wechat_get_native_audio_min_duration__sig: "d",
godot_audio_wechat_get_native_audio_min_duration: function () {
return typeof wx !== "undefined"
? GodotAudio.WX.getNativeMinDuration()
: Number.POSITIVE_INFINITY;
},
godot_audio_wechat_can_cache_pcm__proxy: "sync",
godot_audio_wechat_can_cache_pcm__sig: "ii",
godot_audio_wechat_can_cache_pcm: function (framesTotal) {
return Number(
typeof wx !== "undefined" &&
44 + framesTotal * 4 <= GodotAudio.WX.cacheLimitBytes
);
},
godot_audio_sample_stream_is_registered__proxy: "sync",
godot_audio_sample_stream_is_registered__sig: "ii",
/**
* Returns if the sample stream is registered
* @param {number} streamObjectIdStrPtr Pointer of the streamObjectId
* @returns {number}
*/
godot_audio_sample_stream_is_registered: function (streamObjectIdStrPtr) {
const streamObjectId = GodotRuntime.parseString(streamObjectIdStrPtr);
if (typeof wx !== "undefined" && GodotAudio.WX.isStreamRegistered(streamObjectId)) {
return 1;
}
return Number(GodotAudio.Sample.getSampleOrNull(streamObjectId) != null);
},
godot_audio_sample_register_native_stream__proxy: "sync",
godot_audio_sample_register_native_stream__sig: "viiiiiiiiii",
godot_audio_sample_register_native_stream: function (
streamObjectIdStrPtr,
sourcePathStrPtr,
sourceUidStrPtr,
contentHashStrPtr,
dataPtr,
dataSize,
codecStrPtr,
loopModeStrPtr,
framesTotal,
sampleRate
) {
if (typeof wx === "undefined") {
return;
}
GodotAudio.WX.registerNativeStream(
GodotRuntime.parseString(streamObjectIdStrPtr),
GodotRuntime.parseString(sourcePathStrPtr),
GodotRuntime.parseString(sourceUidStrPtr),
GodotRuntime.parseString(contentHashStrPtr),
dataPtr,
dataSize,
GodotRuntime.parseString(codecStrPtr),
GodotRuntime.parseString(loopModeStrPtr),
framesTotal,
sampleRate
);
},
godot_audio_sample_register_stream__proxy: "sync",
godot_audio_sample_register_stream__sig: "viiiiiii",
/**
* Registers a stream.
* @param {number} streamObjectIdStrPtr StreamObjectId pointer
* @param {number} framesPtr Frames pointer
* @param {number} framesTotal Frames total value
* @param {number} loopModeStrPtr Loop mode pointer
* @param {number} loopBegin Loop begin value
* @param {number} loopEnd Loop end value
* @returns {void}
*/
godot_audio_sample_register_stream: function (
streamObjectIdStrPtr,
framesPtr,
framesTotal,
loopModeStrPtr,
loopBegin,
loopEnd
) {
const streamObjectId = GodotRuntime.parseString(streamObjectIdStrPtr);
const loopMode = GodotRuntime.parseString(loopModeStrPtr);
// Short samples use Web Audio on every web runtime, including WeChat.
const BYTES_PER_FLOAT32 = 4;
const numberOfChannels = 2;
const sampleRate = GodotAudio.ctx.sampleRate;
/** @type {Float32Array} */
const subLeft = GodotRuntime.heapSub(HEAPF32, framesPtr, framesTotal);
/** @type {Float32Array} */
const subRight = GodotRuntime.heapSub(HEAPF32, framesPtr + framesTotal * BYTES_PER_FLOAT32, framesTotal);
const audioBuffer = GodotAudio.ctx.createBuffer(numberOfChannels, framesTotal, sampleRate);
audioBuffer.copyToChannel(new Float32Array(subLeft), 0, 0);
audioBuffer.copyToChannel(new Float32Array(subRight), 1, 0);
GodotAudio.Sample.create(
{
id: streamObjectId,
audioBuffer,
},
{
loopBegin,
loopEnd,
loopMode,
numberOfChannels,
sampleRate,
}
);
},
godot_audio_sample_unregister_stream__proxy: "sync",
godot_audio_sample_unregister_stream__sig: "vi",
/**
* Unregisters a stream.
* @param {number} streamObjectIdStrPtr StreamObjectId pointer
* @returns {void}
*/
godot_audio_sample_unregister_stream: function (streamObjectIdStrPtr) {
const streamObjectId = GodotRuntime.parseString(streamObjectIdStrPtr);
if (typeof wx !== "undefined" && GodotAudio.WX.unregisterStream(streamObjectId)) {
return;
}
// Fallback to Web Audio API
const sample = GodotAudio.Sample.getSampleOrNull(streamObjectId);
if (sample != null) {
sample.clear();
}
},
godot_audio_sample_start__proxy: "sync",
godot_audio_sample_start__sig: "viiiifi",
/**
* Starts a sample.
* @param {number} playbackObjectIdStrPtr Playback object id pointer
* @param {number} streamObjectIdStrPtr Stream object id pointer
* @param {number} busIndex Bus index
* @param {number} offset Sample offset
* @param {number} pitchScale Pitch scale
* @param {number} volumePtr Volume pointer
* @returns {void}
*/
godot_audio_sample_start: function (
playbackObjectIdStrPtr,
streamObjectIdStrPtr,
busIndex,
offset,
pitchScale,
volumePtr
) {
/** @type {string} */
const playbackObjectId = GodotRuntime.parseString(playbackObjectIdStrPtr);
/** @type {string} */
const streamObjectId = GodotRuntime.parseString(streamObjectIdStrPtr);
if (typeof wx !== "undefined" && GodotAudio.WX.isStreamRegistered(streamObjectId)) {
GodotAudio.WX.startSample(playbackObjectId, streamObjectId, busIndex, offset, pitchScale, volumePtr);
return;
}
// Fallback to Web Audio API
/** @type {Float32Array} */
const volume = GodotRuntime.heapSub(HEAPF32, volumePtr, 8);
/** @type {SampleNodeOptions} */
const startOptions = {
offset,
volume,
playbackRate: 1,
pitchScale,
start: true,
};
GodotAudio.start_sample(playbackObjectId, streamObjectId, busIndex, startOptions);
},
godot_audio_sample_stop__proxy: "sync",
godot_audio_sample_stop__sig: "vi",
/**
* Stops a sample from playing.
* @param {number} playbackObjectIdStrPtr Playback object id pointer
* @returns {void}
*/
godot_audio_sample_stop: function (playbackObjectIdStrPtr) {
const playbackObjectId = GodotRuntime.parseString(playbackObjectIdStrPtr);
if (typeof wx !== "undefined" && GodotAudio.WX.stopSample(playbackObjectId)) {
return;
}
// Fallback to Web Audio API
GodotAudio.stop_sample(playbackObjectId);
},
godot_audio_sample_set_pause__proxy: "sync",
godot_audio_sample_set_pause__sig: "vii",
/**
* Sets the pause state of a sample.
* @param {number} playbackObjectIdStrPtr Playback object id pointer
* @param {number} pause Pause state
*/
godot_audio_sample_set_pause: function (playbackObjectIdStrPtr, pause) {
const playbackObjectId = GodotRuntime.parseString(playbackObjectIdStrPtr);
if (typeof wx !== "undefined" && GodotAudio.WX.setPause(playbackObjectId, Boolean(pause))) {
return;
}
// Fallback to Web Audio API
GodotAudio.sample_set_pause(playbackObjectId, Boolean(pause));
},
godot_audio_sample_is_active__proxy: "sync",
godot_audio_sample_is_active__sig: "ii",
/**
* Returns if the sample is active.
* @param {number} playbackObjectIdStrPtr Playback object id pointer
* @returns {number}
*/
godot_audio_sample_is_active: function (playbackObjectIdStrPtr) {
const playbackObjectId = GodotRuntime.parseString(playbackObjectIdStrPtr);
if (typeof wx !== "undefined" && GodotAudio.WX.isActive(playbackObjectId)) {
return Number(GodotAudio.WX.isActive(playbackObjectId));
}
// Fallback to Web Audio API
return Number(GodotAudio.sampleNodes.has(playbackObjectId));
},
godot_audio_get_sample_playback_position__proxy: "sync",
godot_audio_get_sample_playback_position__sig: "di",
/**
* Returns the position of the playback position.
* @param {number} playbackObjectIdStrPtr Playback object id pointer
* @returns {number}
*/
godot_audio_get_sample_playback_position: function (playbackObjectIdStrPtr) {
const playbackObjectId = GodotRuntime.parseString(playbackObjectIdStrPtr);
if (typeof wx !== "undefined" && GodotAudio.WX.isActive(playbackObjectId)) {
return GodotAudio.WX.getPosition(playbackObjectId);
}
// Fallback to Web Audio API
const sampleNode = GodotAudio.SampleNode.getSampleNodeOrNull(playbackObjectId);
if (sampleNode == null) {
return 0;
}
return sampleNode.getPlaybackPosition();
},
godot_audio_sample_update_pitch_scale__proxy: "sync",
godot_audio_sample_update_pitch_scale__sig: "vii",
/**
* Updates the pitch scale of a sample.
* @param {number} playbackObjectIdStrPtr Playback object id pointer
* @param {number} pitchScale Pitch scale value
* @returns {void}
*/
godot_audio_sample_update_pitch_scale: function (playbackObjectIdStrPtr, pitchScale) {
const playbackObjectId = GodotRuntime.parseString(playbackObjectIdStrPtr);
if (
typeof wx !== "undefined" &&
GodotAudio.WX.updatePitchScale(playbackObjectId, pitchScale)
) {
return;
}
// Fallback to Web Audio API
GodotAudio.update_sample_pitch_scale(playbackObjectId, pitchScale);
},
godot_audio_sample_set_volumes_linear__proxy: "sync",
godot_audio_sample_set_volumes_linear__sig: "vii",
/**
* Sets the volumes linear of each mentioned bus for the sample.
* @param {number} playbackObjectIdStrPtr Playback object id pointer
* @param {number} busesPtr Buses array pointer
* @param {number} busesSize Buses array size
* @param {number} volumesPtr Volumes array pointer
* @param {number} volumesSize Volumes array size
* @returns {void}
*/
godot_audio_sample_set_volumes_linear: function (
playbackObjectIdStrPtr,
busesPtr,
busesSize,
volumesPtr,
volumesSize
) {
/** @type {string} */
const playbackObjectId = GodotRuntime.parseString(playbackObjectIdStrPtr);
if (typeof wx !== "undefined" && GodotAudio.WX.updateVolume(playbackObjectId, volumesPtr)) {
return;
}
// Fallback to Web Audio API
/** @type {Uint32Array} */
const buses = GodotRuntime.heapSub(HEAP32, busesPtr, busesSize);
/** @type {Float32Array} */
const volumes = GodotRuntime.heapSub(HEAPF32, volumesPtr, volumesSize);
GodotAudio.sample_set_volumes_linear(playbackObjectId, Array.from(buses), volumes);
},
godot_audio_sample_bus_set_count__proxy: "sync",
godot_audio_sample_bus_set_count__sig: "vi",
/**
* Sets the bus count.
* @param {number} count Bus count
* @returns {void}
*/
godot_audio_sample_bus_set_count: function (count) {
GodotAudio.set_sample_bus_count(count);
},
godot_audio_sample_bus_remove__proxy: "sync",
godot_audio_sample_bus_remove__sig: "vi",
/**
* Removes a bus.
* @param {number} index Index of the bus to remove
* @returns {void}
*/
godot_audio_sample_bus_remove: function (index) {
GodotAudio.remove_sample_bus(index);
},
godot_audio_sample_bus_add__proxy: "sync",
godot_audio_sample_bus_add__sig: "vi",
/**
* Adds a bus at the defined position.
* @param {number} atPos Position to add the bus
* @returns {void}
*/
godot_audio_sample_bus_add: function (atPos) {
GodotAudio.add_sample_bus(atPos);
},
godot_audio_sample_bus_move__proxy: "sync",
godot_audio_sample_bus_move__sig: "vii",
/**
* Moves the bus from a position to another.
* @param {number} fromPos Position of the bus to move
* @param {number} toPos Final position of the bus
* @returns {void}
*/
godot_audio_sample_bus_move: function (fromPos, toPos) {
GodotAudio.move_sample_bus(fromPos, toPos);
},
godot_audio_sample_bus_set_send__proxy: "sync",
godot_audio_sample_bus_set_send__sig: "vii",
/**
* Sets the "send" of a bus.
* @param {number} bus Position of the bus to set the send
* @param {number} sendIndex Position of the "send" bus
* @returns {void}
*/
godot_audio_sample_bus_set_send: function (bus, sendIndex) {
GodotAudio.set_sample_bus_send(bus, sendIndex);
},
godot_audio_sample_bus_set_volume_db__proxy: "sync",
godot_audio_sample_bus_set_volume_db__sig: "vii",
/**
* Sets the volume db of a bus.
* @param {number} bus Position of the bus to set the volume db
* @param {number} volumeDb Volume db to set
* @returns {void}
*/
godot_audio_sample_bus_set_volume_db: function (bus, volumeDb) {
if (typeof wx !== "undefined") {
GodotAudio.WX.setBusVolume(bus, volumeDb);
}
GodotAudio.set_sample_bus_volume_db(bus, volumeDb);
},
godot_audio_sample_bus_set_solo__proxy: "sync",
godot_audio_sample_bus_set_solo__sig: "vii",
/**
* Sets the state of solo for a bus
* @param {number} bus Position of the bus to set the solo state
* @param {number} enable State of the solo
* @returns {void}
*/
godot_audio_sample_bus_set_solo: function (bus, enable) {
GodotAudio.set_sample_bus_solo(bus, Boolean(enable));
},
godot_audio_sample_bus_set_mute__proxy: "sync",
godot_audio_sample_bus_set_mute__sig: "vii",
/**
* Sets the state of mute for a bus
* @param {number} bus Position of the bus to set the mute state
* @param {number} enable State of the mute
* @returns {void}
*/
godot_audio_sample_bus_set_mute: function (bus, enable) {
if (typeof wx !== "undefined") {
GodotAudio.WX.setBusMute(bus, Boolean(enable));
}
GodotAudio.set_sample_bus_mute(bus, Boolean(enable));
},
godot_audio_sample_set_finished_callback__proxy: "sync",
godot_audio_sample_set_finished_callback__sig: "vi",
/**
* Sets the finished callback
* @param {Number} callbackPtr Finished callback pointer
* @returns {void}
*/
godot_audio_sample_set_finished_callback: function (callbackPtr) {
GodotAudio.sampleFinishedCallback = GodotRuntime.get_func(callbackPtr);
},
};
autoAddDeps(_GodotAudio, "$GodotAudio");
mergeInto(LibraryManager.library, _GodotAudio);
/**
* The AudioWorklet API driver, used when threads are available.
*/
const GodotAudioWorklet = {
$GodotAudioWorklet__deps: ["$GodotAudio", "$GodotConfig"],
$GodotAudioWorklet: {
promise: null,
worklet: null,
ring_buffer: null,
create: function (channels) {
// const path = GodotConfig.locate_file('godot.audio.worklet.js');
// GodotAudioWorklet.promise = GodotAudio.ctx.audioWorklet
// .addModule(path)
// .then(function () {
// GodotAudioWorklet.worklet = new AudioWorkletNode(
// GodotAudio.ctx,
// 'godot-processor',
// {
// outputChannelCount: [channels],
// }
// );
// return Promise.resolve();
// });
// GodotAudio.driver = GodotAudioWorklet;
},
start: function (in_buf, out_buf, state) {
GodotAudioWorklet.promise.then(function () {
const node = GodotAudioWorklet.worklet;
node.connect(GodotAudio.ctx.destination);
node.port.postMessage({
cmd: "start",
data: [state, in_buf, out_buf],
});
node.port.onmessage = function (event) {
GodotRuntime.error(event.data);
};
});
},
start_no_threads: function (p_out_buf, p_out_size, out_callback, p_in_buf, p_in_size, in_callback) {
function RingBuffer() {
let wpos = 0;
let rpos = 0;
let pending_samples = 0;
const wbuf = new Float32Array(p_out_size);
function send(port) {
if (pending_samples === 0) {
return;
}
const buffer = GodotRuntime.heapSub(HEAPF32, p_out_buf, p_out_size);
const size = buffer.length;
const tot_sent = pending_samples;
out_callback(wpos, pending_samples);
if (wpos + pending_samples >= size) {
const high = size - wpos;
wbuf.set(buffer.subarray(wpos, size));
pending_samples -= high;
wpos = 0;
}
if (pending_samples > 0) {
wbuf.set(buffer.subarray(wpos, wpos + pending_samples), tot_sent - pending_samples);
}
port.postMessage({
cmd: "chunk",
data: wbuf.subarray(0, tot_sent),
});
wpos += pending_samples;
pending_samples = 0;
}
this.receive = function (recv_buf) {
const buffer = GodotRuntime.heapSub(HEAPF32, p_in_buf, p_in_size);
const from = rpos;
let to_write = recv_buf.length;
let high = 0;
if (rpos + to_write >= p_in_size) {
high = p_in_size - rpos;
buffer.set(recv_buf.subarray(0, high), rpos);
to_write -= high;
rpos = 0;
}
if (to_write) {
buffer.set(recv_buf.subarray(high, to_write), rpos);
}
in_callback(from, recv_buf.length);
rpos += to_write;
};
this.consumed = function (size, port) {
pending_samples += size;
send(port);
};
}
GodotAudioWorklet.ring_buffer = new RingBuffer();
GodotAudioWorklet.promise.then(function () {
const node = GodotAudioWorklet.worklet;
const buffer = GodotRuntime.heapSlice(HEAPF32, p_out_buf, p_out_size);
node.connect(GodotAudio.ctx.destination);
node.port.postMessage({
cmd: "start_nothreads",
data: [buffer, p_in_size],
});
node.port.onmessage = function (event) {
if (!GodotAudioWorklet.worklet) {
return;
}
if (event.data["cmd"] === "read") {
const read = event.data["data"];
GodotAudioWorklet.ring_buffer.consumed(read, GodotAudioWorklet.worklet.port);
} else if (event.data["cmd"] === "input") {
const buf = event.data["data"];
if (buf.length > p_in_size) {
GodotRuntime.error("Input chunk is too big");
return;
}
GodotAudioWorklet.ring_buffer.receive(buf);
} else {
GodotRuntime.error(event.data);
}
};
});
},
get_node: function () {
return GodotAudioWorklet.worklet;
},
close: function () {
return new Promise(function (resolve, reject) {
if (GodotAudioWorklet.promise === null) {
return;
}
const p = GodotAudioWorklet.promise;
p.then(function () {
GodotAudioWorklet.worklet.port.postMessage({
cmd: "stop",
data: null,
});
GodotAudioWorklet.worklet.disconnect();
GodotAudioWorklet.worklet.port.onmessage = null;
GodotAudioWorklet.worklet = null;
GodotAudioWorklet.promise = null;
resolve();
}).catch(function (err) {
// Aborted?
GodotRuntime.error(err);
});
});
},
},
godot_audio_worklet_create__proxy: "sync",
godot_audio_worklet_create__sig: "ii",
godot_audio_worklet_create: function (channels) {
// try {
// GodotAudioWorklet.create(channels);
// } catch (e) {
// GodotRuntime.error('Error starting AudioDriverWorklet', e);
// return 1;
// }
return 0;
},
godot_audio_worklet_start__proxy: "sync",
godot_audio_worklet_start__sig: "viiiii",
godot_audio_worklet_start: function (p_in_buf, p_in_size, p_out_buf, p_out_size, p_state) {
const out_buffer = GodotRuntime.heapSub(HEAPF32, p_out_buf, p_out_size);
const in_buffer = GodotRuntime.heapSub(HEAPF32, p_in_buf, p_in_size);
const state = GodotRuntime.heapSub(HEAP32, p_state, 4);
GodotAudioWorklet.start(in_buffer, out_buffer, state);
},
godot_audio_worklet_start_no_threads__proxy: "sync",
godot_audio_worklet_start_no_threads__sig: "viiiiii",
godot_audio_worklet_start_no_threads: function (
p_out_buf,
p_out_size,
p_out_callback,
p_in_buf,
p_in_size,
p_in_callback
) {
const out_callback = GodotRuntime.get_func(p_out_callback);
const in_callback = GodotRuntime.get_func(p_in_callback);
GodotAudioWorklet.start_no_threads(p_out_buf, p_out_size, out_callback, p_in_buf, p_in_size, in_callback);
},
godot_audio_worklet_state_wait__sig: "iiii",
godot_audio_worklet_state_wait: function (p_state, p_idx, p_expected, p_timeout) {
Atomics.wait(HEAP32, (p_state >> 2) + p_idx, p_expected, p_timeout);
return Atomics.load(HEAP32, (p_state >> 2) + p_idx);
},
godot_audio_worklet_state_add__sig: "iiii",
godot_audio_worklet_state_add: function (p_state, p_idx, p_value) {
return Atomics.add(HEAP32, (p_state >> 2) + p_idx, p_value);
},
godot_audio_worklet_state_get__sig: "iii",
godot_audio_worklet_state_get: function (p_state, p_idx) {
return Atomics.load(HEAP32, (p_state >> 2) + p_idx);
},
};
autoAddDeps(GodotAudioWorklet, "$GodotAudioWorklet");
mergeInto(LibraryManager.library, GodotAudioWorklet);
/*
* The ScriptProcessorNode API, used as a fallback if AudioWorklet is not available.
*/
const GodotAudioScript = {
$GodotAudioScript__deps: ["$GodotAudio"],
$GodotAudioScript: {
script: null,
create: function (buffer_length, channel_count) {
GodotAudioScript.script = GodotAudio.ctx.createScriptProcessor(buffer_length, 2, channel_count);
GodotAudio.driver = GodotAudioScript;
return GodotAudioScript.script.bufferSize;
},
start: function (p_in_buf, p_in_size, p_out_buf, p_out_size, onprocess) {
GodotAudioScript.script.onaudioprocess = function (event) {
// Read input
const inb = GodotRuntime.heapSub(HEAPF32, p_in_buf, p_in_size);
const input = event.inputBuffer;
if (GodotAudio.input) {
const inlen = input.getChannelData(0).length;
for (let ch = 0; ch < 2; ch++) {
const data = input.getChannelData(ch);
for (let s = 0; s < inlen; s++) {
inb[s * 2 + ch] = data[s];
}
}
}
// Let Godot process the input/output.
onprocess();
// Write the output.
const outb = GodotRuntime.heapSub(HEAPF32, p_out_buf, p_out_size);
const output = event.outputBuffer;
const channels = output.numberOfChannels;
for (let ch = 0; ch < channels; ch++) {
const data = output.getChannelData(ch);
// Loop through samples and assign computed values.
for (let sample = 0; sample < data.length; sample++) {
data[sample] = outb[sample * channels + ch];
}
}
};
GodotAudioScript.script.connect(GodotAudio.ctx.destination);
},
get_node: function () {
return GodotAudioScript.script;
},
close: function () {
return new Promise(function (resolve, reject) {
if (GodotAudioScript.script) {
GodotAudioScript.script.disconnect();
GodotAudioScript.script.onaudioprocess = null;
GodotAudioScript.script = null;
}
resolve();
});
},
},
godot_audio_script_create__proxy: "sync",
godot_audio_script_create__sig: "iii",
godot_audio_script_create: function (buffer_length, channel_count) {
const buf_len = GodotRuntime.getHeapValue(buffer_length, "i32");
try {
const out_len = GodotAudioScript.create(buf_len, channel_count);
GodotRuntime.setHeapValue(buffer_length, out_len, "i32");
} catch (e) {
GodotRuntime.error("Error starting AudioDriverScriptProcessor", e);
return 1;
}
return 0;
},
godot_audio_script_start__proxy: "sync",
godot_audio_script_start__sig: "viiiii",
godot_audio_script_start: function (p_in_buf, p_in_size, p_out_buf, p_out_size, p_cb) {
const onprocess = GodotRuntime.get_func(p_cb);
GodotAudioScript.start(p_in_buf, p_in_size, p_out_buf, p_out_size, onprocess);
},
};
autoAddDeps(GodotAudioScript, "$GodotAudioScript");
mergeInto(LibraryManager.library, GodotAudioScript);
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |