forked from sent/waves
4252 lines
172 KiB
JavaScript
4252 lines
172 KiB
JavaScript
'use strict';
|
|
{
|
|
window.DOMHandler = class DOMHandler {
|
|
constructor(iRuntime, componentId) {
|
|
this._iRuntime = iRuntime;
|
|
this._componentId = componentId;
|
|
this._hasTickCallback = false;
|
|
this._tickCallback = ()=>this.Tick()
|
|
}
|
|
Attach() {}
|
|
PostToRuntime(handler, data, dispatchOpts, transferables) {
|
|
this._iRuntime.PostToRuntimeComponent(this._componentId, handler, data, dispatchOpts, transferables)
|
|
}
|
|
PostToRuntimeAsync(handler, data, dispatchOpts, transferables) {
|
|
return this._iRuntime.PostToRuntimeComponentAsync(this._componentId, handler, data, dispatchOpts, transferables)
|
|
}
|
|
_PostToRuntimeMaybeSync(name, data, dispatchOpts) {
|
|
if (this._iRuntime.UsesWorker())
|
|
this.PostToRuntime(name, data, dispatchOpts);
|
|
else
|
|
this._iRuntime._GetLocalRuntime()["_OnMessageFromDOM"]({
|
|
"type": "event",
|
|
"component": this._componentId,
|
|
"handler": name,
|
|
"dispatchOpts": dispatchOpts || null,
|
|
"data": data,
|
|
"responseId": null
|
|
})
|
|
}
|
|
AddRuntimeMessageHandler(handler, func) {
|
|
this._iRuntime.AddRuntimeComponentMessageHandler(this._componentId, handler, func)
|
|
}
|
|
AddRuntimeMessageHandlers(list) {
|
|
for (const [handler,func] of list)
|
|
this.AddRuntimeMessageHandler(handler, func)
|
|
}
|
|
GetRuntimeInterface() {
|
|
return this._iRuntime
|
|
}
|
|
GetComponentID() {
|
|
return this._componentId
|
|
}
|
|
_StartTicking() {
|
|
if (this._hasTickCallback)
|
|
return;
|
|
this._iRuntime._AddRAFCallback(this._tickCallback);
|
|
this._hasTickCallback = true
|
|
}
|
|
_StopTicking() {
|
|
if (!this._hasTickCallback)
|
|
return;
|
|
this._iRuntime._RemoveRAFCallback(this._tickCallback);
|
|
this._hasTickCallback = false
|
|
}
|
|
Tick() {}
|
|
}
|
|
;
|
|
window.RateLimiter = class RateLimiter {
|
|
constructor(callback, interval) {
|
|
this._callback = callback;
|
|
this._interval = interval;
|
|
this._timerId = -1;
|
|
this._lastCallTime = -Infinity;
|
|
this._timerCallFunc = ()=>this._OnTimer();
|
|
this._ignoreReset = false;
|
|
this._canRunImmediate = false
|
|
}
|
|
SetCanRunImmediate(c) {
|
|
this._canRunImmediate = !!c
|
|
}
|
|
Call() {
|
|
if (this._timerId !== -1)
|
|
return;
|
|
const nowTime = Date.now();
|
|
const timeSinceLastCall = nowTime - this._lastCallTime;
|
|
const interval = this._interval;
|
|
if (timeSinceLastCall >= interval && this._canRunImmediate) {
|
|
this._lastCallTime = nowTime;
|
|
this._RunCallback()
|
|
} else
|
|
this._timerId = self.setTimeout(this._timerCallFunc, Math.max(interval - timeSinceLastCall, 4))
|
|
}
|
|
_RunCallback() {
|
|
this._ignoreReset = true;
|
|
this._callback();
|
|
this._ignoreReset = false
|
|
}
|
|
Reset() {
|
|
if (this._ignoreReset)
|
|
return;
|
|
this._CancelTimer();
|
|
this._lastCallTime = Date.now()
|
|
}
|
|
_OnTimer() {
|
|
this._timerId = -1;
|
|
this._lastCallTime = Date.now();
|
|
this._RunCallback()
|
|
}
|
|
_CancelTimer() {
|
|
if (this._timerId !== -1) {
|
|
self.clearTimeout(this._timerId);
|
|
this._timerId = -1
|
|
}
|
|
}
|
|
Release() {
|
|
this._CancelTimer();
|
|
this._callback = null;
|
|
this._timerCallFunc = null
|
|
}
|
|
}
|
|
}
|
|
;'use strict';
|
|
{
|
|
window.DOMElementHandler = class DOMElementHandler extends self.DOMHandler {
|
|
constructor(iRuntime, componentId) {
|
|
super(iRuntime, componentId);
|
|
this._elementMap = new Map;
|
|
this._autoAttach = true;
|
|
this.AddRuntimeMessageHandlers([["create", e=>this._OnCreate(e)], ["destroy", e=>this._OnDestroy(e)], ["set-visible", e=>this._OnSetVisible(e)], ["update-position", e=>this._OnUpdatePosition(e)], ["update-state", e=>this._OnUpdateState(e)], ["focus", e=>this._OnSetFocus(e)], ["set-css-style", e=>this._OnSetCssStyle(e)], ["set-attribute", e=>this._OnSetAttribute(e)], ["remove-attribute", e=>this._OnRemoveAttribute(e)]]);
|
|
this.AddDOMElementMessageHandler("get-element", elem=>elem)
|
|
}
|
|
SetAutoAttach(e) {
|
|
this._autoAttach = !!e
|
|
}
|
|
AddDOMElementMessageHandler(handler, func) {
|
|
this.AddRuntimeMessageHandler(handler, e=>{
|
|
const elementId = e["elementId"];
|
|
const elem = this._elementMap.get(elementId);
|
|
return func(elem, e)
|
|
}
|
|
)
|
|
}
|
|
_OnCreate(e) {
|
|
const elementId = e["elementId"];
|
|
const elem = this.CreateElement(elementId, e);
|
|
this._elementMap.set(elementId, elem);
|
|
if (!e["isVisible"])
|
|
elem.style.display = "none";
|
|
const focusElem = this._GetFocusElement(elem);
|
|
focusElem.addEventListener("focus", e=>this._OnFocus(elementId));
|
|
focusElem.addEventListener("blur", e=>this._OnBlur(elementId));
|
|
if (this._autoAttach)
|
|
document.body.appendChild(elem)
|
|
}
|
|
CreateElement(elementId, e) {
|
|
throw new Error("required override");
|
|
}
|
|
DestroyElement(elem) {}
|
|
_OnDestroy(e) {
|
|
const elementId = e["elementId"];
|
|
const elem = this._elementMap.get(elementId);
|
|
this.DestroyElement(elem);
|
|
if (this._autoAttach)
|
|
elem.parentElement.removeChild(elem);
|
|
this._elementMap.delete(elementId)
|
|
}
|
|
PostToRuntimeElement(handler, elementId, data) {
|
|
if (!data)
|
|
data = {};
|
|
data["elementId"] = elementId;
|
|
this.PostToRuntime(handler, data)
|
|
}
|
|
_PostToRuntimeElementMaybeSync(handler, elementId, data) {
|
|
if (!data)
|
|
data = {};
|
|
data["elementId"] = elementId;
|
|
this._PostToRuntimeMaybeSync(handler, data)
|
|
}
|
|
_OnSetVisible(e) {
|
|
if (!this._autoAttach)
|
|
return;
|
|
const elem = this._elementMap.get(e["elementId"]);
|
|
elem.style.display = e["isVisible"] ? "" : "none"
|
|
}
|
|
_OnUpdatePosition(e) {
|
|
if (!this._autoAttach)
|
|
return;
|
|
const elem = this._elementMap.get(e["elementId"]);
|
|
elem.style.left = e["left"] + "px";
|
|
elem.style.top = e["top"] + "px";
|
|
elem.style.width = e["width"] + "px";
|
|
elem.style.height = e["height"] + "px";
|
|
const fontSize = e["fontSize"];
|
|
if (fontSize !== null)
|
|
elem.style.fontSize = fontSize + "em"
|
|
}
|
|
_OnUpdateState(e) {
|
|
const elem = this._elementMap.get(e["elementId"]);
|
|
this.UpdateState(elem, e)
|
|
}
|
|
UpdateState(elem, e) {
|
|
throw new Error("required override");
|
|
}
|
|
_GetFocusElement(elem) {
|
|
return elem
|
|
}
|
|
_OnFocus(elementId) {
|
|
this.PostToRuntimeElement("elem-focused", elementId)
|
|
}
|
|
_OnBlur(elementId) {
|
|
this.PostToRuntimeElement("elem-blurred", elementId)
|
|
}
|
|
_OnSetFocus(e) {
|
|
const elem = this._GetFocusElement(this._elementMap.get(e["elementId"]));
|
|
if (e["focus"])
|
|
elem.focus();
|
|
else
|
|
elem.blur()
|
|
}
|
|
_OnSetCssStyle(e) {
|
|
const elem = this._elementMap.get(e["elementId"]);
|
|
elem.style[e["prop"]] = e["val"]
|
|
}
|
|
_OnSetAttribute(e) {
|
|
const elem = this._elementMap.get(e["elementId"]);
|
|
elem.setAttribute(e["name"], e["val"])
|
|
}
|
|
_OnRemoveAttribute(e) {
|
|
const elem = this._elementMap.get(e["elementId"]);
|
|
elem.removeAttribute(e["name"])
|
|
}
|
|
GetElementById(elementId) {
|
|
return this._elementMap.get(elementId)
|
|
}
|
|
}
|
|
}
|
|
;'use strict';
|
|
{
|
|
const isiOSLike = /(iphone|ipod|ipad|macos|macintosh|mac os x)/i.test(navigator.userAgent);
|
|
function AddScript(url) {
|
|
if (url.isStringSrc) {
|
|
const elem = document.createElement("script");
|
|
elem.async = false;
|
|
elem.textContent = url.str;
|
|
document.head.appendChild(elem)
|
|
} else
|
|
return new Promise((resolve,reject)=>{
|
|
const elem = document.createElement("script");
|
|
elem.onload = resolve;
|
|
elem.onerror = reject;
|
|
elem.async = false;
|
|
elem.src = url;
|
|
document.head.appendChild(elem)
|
|
}
|
|
)
|
|
}
|
|
let tmpAudio = new Audio;
|
|
const supportedAudioFormats = {
|
|
"audio/webm; codecs=opus": !!tmpAudio.canPlayType("audio/webm; codecs=opus"),
|
|
"audio/ogg; codecs=opus": !!tmpAudio.canPlayType("audio/ogg; codecs=opus"),
|
|
"audio/webm; codecs=vorbis": !!tmpAudio.canPlayType("audio/webm; codecs=vorbis"),
|
|
"audio/ogg; codecs=vorbis": !!tmpAudio.canPlayType("audio/ogg; codecs=vorbis"),
|
|
"audio/mp4": !!tmpAudio.canPlayType("audio/mp4"),
|
|
"audio/mpeg": !!tmpAudio.canPlayType("audio/mpeg")
|
|
};
|
|
tmpAudio = null;
|
|
async function BlobToString(blob) {
|
|
const arrayBuffer = await BlobToArrayBuffer(blob);
|
|
const textDecoder = new TextDecoder("utf-8");
|
|
return textDecoder.decode(arrayBuffer)
|
|
}
|
|
function BlobToArrayBuffer(blob) {
|
|
return new Promise((resolve,reject)=>{
|
|
const fileReader = new FileReader;
|
|
fileReader.onload = e=>resolve(e.target.result);
|
|
fileReader.onerror = err=>reject(err);
|
|
fileReader.readAsArrayBuffer(blob)
|
|
}
|
|
)
|
|
}
|
|
const queuedArrayBufferReads = [];
|
|
let activeArrayBufferReads = 0;
|
|
const MAX_ARRAYBUFFER_READS = 8;
|
|
window["RealFile"] = window["File"];
|
|
const domHandlerClasses = [];
|
|
const runtimeEventHandlers = new Map;
|
|
const pendingResponsePromises = new Map;
|
|
let nextResponseId = 0;
|
|
const runOnStartupFunctions = [];
|
|
self.runOnStartup = function runOnStartup(f) {
|
|
if (typeof f !== "function")
|
|
throw new Error("runOnStartup called without a function");
|
|
runOnStartupFunctions.push(f)
|
|
}
|
|
;
|
|
const WEBVIEW_EXPORT_TYPES = new Set(["cordova", "playable-ad", "instant-games"]);
|
|
function IsWebViewExportType(exportType) {
|
|
return WEBVIEW_EXPORT_TYPES.has(exportType)
|
|
}
|
|
window.RuntimeInterface = class RuntimeInterface {
|
|
constructor(opts) {
|
|
this._useWorker = opts.useWorker;
|
|
this._messageChannelPort = null;
|
|
this._baseUrl = "";
|
|
this._scriptFolder = opts.scriptFolder;
|
|
this._workerScriptBlobURLs = {};
|
|
this._worker = null;
|
|
this._localRuntime = null;
|
|
this._loadingElem = null;
|
|
this._domHandlers = [];
|
|
this._runtimeDomHandler = null;
|
|
this._canvas = null;
|
|
this._jobScheduler = null;
|
|
this._rafId = -1;
|
|
this._rafFunc = ()=>this._OnRAFCallback();
|
|
this._rafCallbacks = [];
|
|
this._exportType = opts.exportType;
|
|
if (this._useWorker && (typeof OffscreenCanvas === "undefined" || !navigator["userActivation"]))
|
|
this._useWorker = false;
|
|
if (IsWebViewExportType(this._exportType) && this._useWorker) {
|
|
console.warn("[C3 runtime] Worker mode is enabled and supported, but is disabled in WebViews due to crbug.com/923007. Reverting to DOM mode.");
|
|
this._useWorker = false
|
|
}
|
|
this._localFileBlobs = null;
|
|
this._localFileStrings = null;
|
|
if ((this._exportType === "html5" || this._exportType === "playable-ad") && location.protocol.substr(0, 4) === "file")
|
|
alert("Exported games won't work until you upload them. (When running on the file: protocol, browsers block many features from working for security reasons.)");
|
|
this.AddRuntimeComponentMessageHandler("runtime", "cordova-fetch-local-file", e=>this._OnCordovaFetchLocalFile(e));
|
|
this.AddRuntimeComponentMessageHandler("runtime", "create-job-worker", e=>this._OnCreateJobWorker(e));
|
|
if (this._exportType === "cordova")
|
|
document.addEventListener("deviceready", ()=>this._Init(opts));
|
|
else
|
|
this._Init(opts)
|
|
}
|
|
Release() {
|
|
this._CancelAnimationFrame();
|
|
if (this._messageChannelPort) {
|
|
this._messageChannelPort.onmessage = null;
|
|
this._messageChannelPort = null
|
|
}
|
|
if (this._worker) {
|
|
this._worker.terminate();
|
|
this._worker = null
|
|
}
|
|
if (this._localRuntime) {
|
|
this._localRuntime.Release();
|
|
this._localRuntime = null
|
|
}
|
|
if (this._canvas) {
|
|
this._canvas.parentElement.removeChild(this._canvas);
|
|
this._canvas = null
|
|
}
|
|
}
|
|
GetCanvas() {
|
|
return this._canvas
|
|
}
|
|
GetBaseURL() {
|
|
return this._baseUrl
|
|
}
|
|
UsesWorker() {
|
|
return this._useWorker
|
|
}
|
|
GetExportType() {
|
|
return this._exportType
|
|
}
|
|
GetScriptFolder() {
|
|
return this._scriptFolder
|
|
}
|
|
IsiOSCordova() {
|
|
return isiOSLike && this._exportType === "cordova"
|
|
}
|
|
IsiOSWebView() {
|
|
return isiOSLike && IsWebViewExportType(this._exportType) || navigator["standalone"]
|
|
}
|
|
async _Init(opts) {
|
|
if (this._exportType === "preview") {
|
|
this._loadingElem = document.createElement("div");
|
|
this._loadingElem.className = "previewLoadingMessage";
|
|
this._loadingElem.textContent = opts.previewLoadingMessage;
|
|
document.body.appendChild(this._loadingElem)
|
|
}
|
|
if (this._exportType === "playable-ad") {
|
|
this._localFileBlobs = self["c3_base64files"];
|
|
this._localFileStrings = {};
|
|
await this._ConvertDataUrisToBlobs();
|
|
for (let i = 0, len = opts.engineScripts.length; i < len; ++i) {
|
|
const src = opts.engineScripts[i].toLowerCase();
|
|
if (this._localFileStrings.hasOwnProperty(src))
|
|
opts.engineScripts[i] = {
|
|
isStringSrc: true,
|
|
str: this._localFileStrings[src]
|
|
};
|
|
else if (this._localFileBlobs.hasOwnProperty(src))
|
|
opts.engineScripts[i] = URL.createObjectURL(this._localFileBlobs[src])
|
|
}
|
|
}
|
|
if (opts.baseUrl)
|
|
this._baseUrl = opts.baseUrl;
|
|
else {
|
|
const origin = location.origin;
|
|
this._baseUrl = (origin === "null" ? "file:///" : origin) + location.pathname;
|
|
const i = this._baseUrl.lastIndexOf("/");
|
|
if (i !== -1)
|
|
this._baseUrl = this._baseUrl.substr(0, i + 1)
|
|
}
|
|
if (opts.workerScripts)
|
|
for (const [url,blob] of Object.entries(opts.workerScripts))
|
|
this._workerScriptBlobURLs[url] = URL.createObjectURL(blob);
|
|
const messageChannel = new MessageChannel;
|
|
this._messageChannelPort = messageChannel.port1;
|
|
this._messageChannelPort.onmessage = e=>this["_OnMessageFromRuntime"](e.data);
|
|
if (window["c3_addPortMessageHandler"])
|
|
window["c3_addPortMessageHandler"](e=>this._OnMessageFromDebugger(e));
|
|
this._jobScheduler = new self.JobSchedulerDOM(this);
|
|
await this._jobScheduler.Init();
|
|
this.MaybeForceBodySize();
|
|
if (typeof window["StatusBar"] === "object")
|
|
window["StatusBar"]["hide"]();
|
|
if (typeof window["AndroidFullScreen"] === "object")
|
|
window["AndroidFullScreen"]["immersiveMode"]();
|
|
if (this._useWorker)
|
|
await this._InitWorker(opts, messageChannel.port2);
|
|
else
|
|
await this._InitDOM(opts, messageChannel.port2)
|
|
}
|
|
_GetWorkerURL(url) {
|
|
if (this._workerScriptBlobURLs.hasOwnProperty(url))
|
|
return this._workerScriptBlobURLs[url];
|
|
else if (url.endsWith("/workermain.js") && this._workerScriptBlobURLs.hasOwnProperty("workermain.js"))
|
|
return this._workerScriptBlobURLs["workermain.js"];
|
|
else if (this._exportType === "playable-ad" && this._localFileBlobs.hasOwnProperty(url.toLowerCase()))
|
|
return URL.createObjectURL(this._localFileBlobs[url.toLowerCase()]);
|
|
else
|
|
return url
|
|
}
|
|
async CreateWorker(url, baseUrl, workerOpts) {
|
|
if (url.startsWith("blob:"))
|
|
return new Worker(url,workerOpts);
|
|
if (this.IsiOSCordova() && location.protocol === "file:") {
|
|
const arrayBuffer = await this.CordovaFetchLocalFileAsArrayBuffer(this._scriptFolder + url);
|
|
const blob = new Blob([arrayBuffer],{
|
|
type: "application/javascript"
|
|
});
|
|
return new Worker(URL.createObjectURL(blob),workerOpts)
|
|
}
|
|
const absUrl = new URL(url,baseUrl);
|
|
const isCrossOrigin = location.origin !== absUrl.origin;
|
|
if (isCrossOrigin) {
|
|
const response = await fetch(absUrl);
|
|
if (!response.ok)
|
|
throw new Error("failed to fetch worker script");
|
|
const blob = await response.blob();
|
|
return new Worker(URL.createObjectURL(blob),workerOpts)
|
|
} else
|
|
return new Worker(absUrl,workerOpts)
|
|
}
|
|
_GetWindowInnerWidth() {
|
|
return Math.max(window.innerWidth, 1)
|
|
}
|
|
_GetWindowInnerHeight() {
|
|
return Math.max(window.innerHeight, 1)
|
|
}
|
|
MaybeForceBodySize() {
|
|
if (this.IsiOSWebView()) {
|
|
const docStyle = document["documentElement"].style;
|
|
const bodyStyle = document["body"].style;
|
|
const isPortrait = window.innerWidth < window.innerHeight;
|
|
const width = isPortrait ? window["screen"]["width"] : window["screen"]["height"];
|
|
const height = isPortrait ? window["screen"]["height"] : window["screen"]["width"];
|
|
bodyStyle["height"] = docStyle["height"] = height + "px";
|
|
bodyStyle["width"] = docStyle["width"] = width + "px"
|
|
}
|
|
}
|
|
_GetCommonRuntimeOptions(opts) {
|
|
return {
|
|
"baseUrl": this._baseUrl,
|
|
"windowInnerWidth": this._GetWindowInnerWidth(),
|
|
"windowInnerHeight": this._GetWindowInnerHeight(),
|
|
"devicePixelRatio": window.devicePixelRatio,
|
|
"isFullscreen": RuntimeInterface.IsDocumentFullscreen(),
|
|
"projectData": opts.projectData,
|
|
"previewImageBlobs": window["cr_previewImageBlobs"] || this._localFileBlobs,
|
|
"previewProjectFileBlobs": window["cr_previewProjectFileBlobs"],
|
|
"exportType": opts.exportType,
|
|
"isDebug": self.location.search.indexOf("debug") > -1,
|
|
"ife": !!self.ife,
|
|
"jobScheduler": this._jobScheduler.GetPortData(),
|
|
"supportedAudioFormats": supportedAudioFormats,
|
|
"opusWasmScriptUrl": window["cr_opusWasmScriptUrl"] || this._scriptFolder + "opus.wasm.js",
|
|
"opusWasmBinaryUrl": window["cr_opusWasmBinaryUrl"] || this._scriptFolder + "opus.wasm.wasm",
|
|
"isiOSCordova": this.IsiOSCordova(),
|
|
"isiOSWebView": this.IsiOSWebView(),
|
|
"isFBInstantAvailable": typeof self["FBInstant"] !== "undefined"
|
|
}
|
|
}
|
|
async _InitWorker(opts, port2) {
|
|
const workerMainUrl = this._GetWorkerURL(opts.workerMainUrl);
|
|
this._worker = await this.CreateWorker(workerMainUrl, this._baseUrl, {
|
|
name: "Runtime"
|
|
});
|
|
this._canvas = document.createElement("canvas");
|
|
this._canvas.style.display = "none";
|
|
const offscreenCanvas = this._canvas["transferControlToOffscreen"]();
|
|
document.body.appendChild(this._canvas);
|
|
window["c3canvas"] = this._canvas;
|
|
this._worker.postMessage(Object.assign(this._GetCommonRuntimeOptions(opts), {
|
|
"type": "init-runtime",
|
|
"isInWorker": true,
|
|
"messagePort": port2,
|
|
"canvas": offscreenCanvas,
|
|
"workerDependencyScripts": opts.workerDependencyScripts || [],
|
|
"engineScripts": opts.engineScripts,
|
|
"projectScripts": window.cr_allProjectScripts,
|
|
"projectScriptsStatus": self["C3_ProjectScriptsStatus"]
|
|
}), [port2, offscreenCanvas, ...this._jobScheduler.GetPortTransferables()]);
|
|
this._domHandlers = domHandlerClasses.map(C=>new C(this));
|
|
this._FindRuntimeDOMHandler();
|
|
self["c3_callFunction"] = (name,params)=>this._runtimeDomHandler._InvokeFunctionFromJS(name, params);
|
|
if (this._exportType === "preview")
|
|
self["goToLastErrorScript"] = ()=>this.PostToRuntimeComponent("runtime", "go-to-last-error-script")
|
|
}
|
|
async _InitDOM(opts, port2) {
|
|
this._canvas = document.createElement("canvas");
|
|
this._canvas.style.display = "none";
|
|
document.body.appendChild(this._canvas);
|
|
window["c3canvas"] = this._canvas;
|
|
this._domHandlers = domHandlerClasses.map(C=>new C(this));
|
|
this._FindRuntimeDOMHandler();
|
|
const engineScripts = opts.engineScripts.map(url=>typeof url === "string" ? (new URL(url,this._baseUrl)).toString() : url);
|
|
if (Array.isArray(opts.workerDependencyScripts))
|
|
engineScripts.unshift(...opts.workerDependencyScripts);
|
|
await Promise.all(engineScripts.map(url=>AddScript(url)));
|
|
if (opts.projectScripts && opts.projectScripts.length > 0) {
|
|
const scriptsStatus = self["C3_ProjectScriptsStatus"];
|
|
try {
|
|
await Promise.all(opts.projectScripts.map(e=>AddScript(e[1])));
|
|
if (Object.values(scriptsStatus).some(f=>!f)) {
|
|
self.setTimeout(()=>this._ReportProjectScriptError(scriptsStatus), 100);
|
|
return
|
|
}
|
|
} catch (err) {
|
|
console.error("[Preview] Error loading project scripts: ", err);
|
|
self.setTimeout(()=>this._ReportProjectScriptError(scriptsStatus), 100);
|
|
return
|
|
}
|
|
}
|
|
if (this._exportType === "preview" && typeof self.C3.ScriptsInEvents !== "object") {
|
|
this._RemoveLoadingMessage();
|
|
const msg = "Failed to load JavaScript code used in events. Check all your JavaScript code has valid syntax.";
|
|
console.error("[C3 runtime] " + msg);
|
|
alert(msg);
|
|
return
|
|
}
|
|
const runtimeOpts = Object.assign(this._GetCommonRuntimeOptions(opts), {
|
|
"isInWorker": false,
|
|
"messagePort": port2,
|
|
"canvas": this._canvas,
|
|
"runOnStartupFunctions": runOnStartupFunctions
|
|
});
|
|
this._OnBeforeCreateRuntime();
|
|
this._localRuntime = self["C3_CreateRuntime"](runtimeOpts);
|
|
await self["C3_InitRuntime"](this._localRuntime, runtimeOpts)
|
|
}
|
|
_ReportProjectScriptError(scriptsStatus) {
|
|
this._RemoveLoadingMessage();
|
|
const failedScripts = Object.entries(scriptsStatus).filter(e=>!e[1]).map(e=>e[0]);
|
|
const msg = `Failed to load project script '${failedScripts[0]}'. Check all your JavaScript code has valid syntax.`;
|
|
console.error("[Preview] " + msg);
|
|
alert(msg)
|
|
}
|
|
_OnBeforeCreateRuntime() {
|
|
this._RemoveLoadingMessage()
|
|
}
|
|
_RemoveLoadingMessage() {
|
|
if (this._loadingElem) {
|
|
this._loadingElem.parentElement.removeChild(this._loadingElem);
|
|
this._loadingElem = null
|
|
}
|
|
}
|
|
async _OnCreateJobWorker(e) {
|
|
const outputPort = await this._jobScheduler._CreateJobWorker();
|
|
return {
|
|
"outputPort": outputPort,
|
|
"transferables": [outputPort]
|
|
}
|
|
}
|
|
_GetLocalRuntime() {
|
|
if (this._useWorker)
|
|
throw new Error("not available in worker mode");
|
|
return this._localRuntime
|
|
}
|
|
PostToRuntimeComponent(component, handler, data, dispatchOpts, transferables) {
|
|
this._messageChannelPort.postMessage({
|
|
"type": "event",
|
|
"component": component,
|
|
"handler": handler,
|
|
"dispatchOpts": dispatchOpts || null,
|
|
"data": data,
|
|
"responseId": null
|
|
}, transferables)
|
|
}
|
|
PostToRuntimeComponentAsync(component, handler, data, dispatchOpts, transferables) {
|
|
const responseId = nextResponseId++;
|
|
const ret = new Promise((resolve,reject)=>{
|
|
pendingResponsePromises.set(responseId, {
|
|
resolve,
|
|
reject
|
|
})
|
|
}
|
|
);
|
|
this._messageChannelPort.postMessage({
|
|
"type": "event",
|
|
"component": component,
|
|
"handler": handler,
|
|
"dispatchOpts": dispatchOpts || null,
|
|
"data": data,
|
|
"responseId": responseId
|
|
}, transferables);
|
|
return ret
|
|
}
|
|
["_OnMessageFromRuntime"](data) {
|
|
const type = data["type"];
|
|
if (type === "event")
|
|
return this._OnEventFromRuntime(data);
|
|
else if (type === "result")
|
|
this._OnResultFromRuntime(data);
|
|
else if (type === "runtime-ready")
|
|
this._OnRuntimeReady();
|
|
else if (type === "alert-error") {
|
|
this._RemoveLoadingMessage();
|
|
alert(data["message"])
|
|
} else if (type === "creating-runtime")
|
|
this._OnBeforeCreateRuntime();
|
|
else
|
|
throw new Error(`unknown message '${type}'`);
|
|
}
|
|
_OnEventFromRuntime(e) {
|
|
const component = e["component"];
|
|
const handler = e["handler"];
|
|
const data = e["data"];
|
|
const responseId = e["responseId"];
|
|
const handlerMap = runtimeEventHandlers.get(component);
|
|
if (!handlerMap) {
|
|
console.warn(`[DOM] No event handlers for component '${component}'`);
|
|
return
|
|
}
|
|
const func = handlerMap.get(handler);
|
|
if (!func) {
|
|
console.warn(`[DOM] No handler '${handler}' for component '${component}'`);
|
|
return
|
|
}
|
|
let ret = null;
|
|
try {
|
|
ret = func(data)
|
|
} catch (err) {
|
|
console.error(`Exception in '${component}' handler '${handler}':`, err);
|
|
if (responseId !== null)
|
|
this._PostResultToRuntime(responseId, false, "" + err);
|
|
return
|
|
}
|
|
if (responseId === null)
|
|
return ret;
|
|
else if (ret && ret.then)
|
|
ret.then(result=>this._PostResultToRuntime(responseId, true, result)).catch(err=>{
|
|
console.error(`Rejection from '${component}' handler '${handler}':`, err);
|
|
this._PostResultToRuntime(responseId, false, "" + err)
|
|
}
|
|
);
|
|
else
|
|
this._PostResultToRuntime(responseId, true, ret)
|
|
}
|
|
_PostResultToRuntime(responseId, isOk, result) {
|
|
let transferables;
|
|
if (result && result["transferables"])
|
|
transferables = result["transferables"];
|
|
this._messageChannelPort.postMessage({
|
|
"type": "result",
|
|
"responseId": responseId,
|
|
"isOk": isOk,
|
|
"result": result
|
|
}, transferables)
|
|
}
|
|
_OnResultFromRuntime(data) {
|
|
const responseId = data["responseId"];
|
|
const isOk = data["isOk"];
|
|
const result = data["result"];
|
|
const pendingPromise = pendingResponsePromises.get(responseId);
|
|
if (isOk)
|
|
pendingPromise.resolve(result);
|
|
else
|
|
pendingPromise.reject(result);
|
|
pendingResponsePromises.delete(responseId)
|
|
}
|
|
AddRuntimeComponentMessageHandler(component, handler, func) {
|
|
let handlerMap = runtimeEventHandlers.get(component);
|
|
if (!handlerMap) {
|
|
handlerMap = new Map;
|
|
runtimeEventHandlers.set(component, handlerMap)
|
|
}
|
|
if (handlerMap.has(handler))
|
|
throw new Error(`[DOM] Component '${component}' already has handler '${handler}'`);
|
|
handlerMap.set(handler, func)
|
|
}
|
|
static AddDOMHandlerClass(Class) {
|
|
if (domHandlerClasses.includes(Class))
|
|
throw new Error("DOM handler already added");
|
|
domHandlerClasses.push(Class)
|
|
}
|
|
_FindRuntimeDOMHandler() {
|
|
for (const dh of this._domHandlers)
|
|
if (dh.GetComponentID() === "runtime") {
|
|
this._runtimeDomHandler = dh;
|
|
return
|
|
}
|
|
throw new Error("cannot find runtime DOM handler");
|
|
}
|
|
_OnMessageFromDebugger(e) {
|
|
this.PostToRuntimeComponent("debugger", "message", e)
|
|
}
|
|
_OnRuntimeReady() {
|
|
for (const h of this._domHandlers)
|
|
h.Attach()
|
|
}
|
|
static IsDocumentFullscreen() {
|
|
return !!(document["fullscreenElement"] || document["webkitFullscreenElement"] || document["mozFullScreenElement"])
|
|
}
|
|
async GetRemotePreviewStatusInfo() {
|
|
return await this.PostToRuntimeComponentAsync("runtime", "get-remote-preview-status-info")
|
|
}
|
|
_AddRAFCallback(f) {
|
|
this._rafCallbacks.push(f);
|
|
this._RequestAnimationFrame()
|
|
}
|
|
_RemoveRAFCallback(f) {
|
|
const i = this._rafCallbacks.indexOf(f);
|
|
if (i === -1)
|
|
throw new Error("invalid callback");
|
|
this._rafCallbacks.splice(i, 1);
|
|
if (!this._rafCallbacks.length)
|
|
this._CancelAnimationFrame()
|
|
}
|
|
_RequestAnimationFrame() {
|
|
if (this._rafId === -1 && this._rafCallbacks.length)
|
|
this._rafId = requestAnimationFrame(this._rafFunc)
|
|
}
|
|
_CancelAnimationFrame() {
|
|
if (this._rafId !== -1) {
|
|
cancelAnimationFrame(this._rafId);
|
|
this._rafId = -1
|
|
}
|
|
}
|
|
_OnRAFCallback() {
|
|
this._rafId = -1;
|
|
for (const f of this._rafCallbacks)
|
|
f();
|
|
this._RequestAnimationFrame()
|
|
}
|
|
TryPlayMedia(mediaElem) {
|
|
this._runtimeDomHandler.TryPlayMedia(mediaElem)
|
|
}
|
|
RemovePendingPlay(mediaElem) {
|
|
this._runtimeDomHandler.RemovePendingPlay(mediaElem)
|
|
}
|
|
_PlayPendingMedia() {
|
|
this._runtimeDomHandler._PlayPendingMedia()
|
|
}
|
|
SetSilent(s) {
|
|
this._runtimeDomHandler.SetSilent(s)
|
|
}
|
|
IsAudioFormatSupported(typeStr) {
|
|
return !!supportedAudioFormats[typeStr]
|
|
}
|
|
async _WasmDecodeWebMOpus(arrayBuffer) {
|
|
const result = await this.PostToRuntimeComponentAsync("runtime", "opus-decode", {
|
|
"arrayBuffer": arrayBuffer
|
|
}, null, [arrayBuffer]);
|
|
return new Float32Array(result)
|
|
}
|
|
IsAbsoluteURL(url) {
|
|
return /^(?:[a-z]+:)?\/\//.test(url) || url.substr(0, 5) === "data:" || url.substr(0, 5) === "blob:"
|
|
}
|
|
IsRelativeURL(url) {
|
|
return !this.IsAbsoluteURL(url)
|
|
}
|
|
async _OnCordovaFetchLocalFile(e) {
|
|
const filename = e["filename"];
|
|
switch (e["as"]) {
|
|
case "text":
|
|
return await this.CordovaFetchLocalFileAsText(filename);
|
|
case "buffer":
|
|
return await this.CordovaFetchLocalFileAsArrayBuffer(filename);
|
|
default:
|
|
throw new Error("unsupported type");
|
|
}
|
|
}
|
|
_GetPermissionAPI() {
|
|
const api = window["cordova"] && window["cordova"]["plugins"] && window["cordova"]["plugins"]["permissions"];
|
|
if (typeof api !== "object")
|
|
throw new Error("Permission API is not loaded");
|
|
return api
|
|
}
|
|
_MapPermissionID(api, permission) {
|
|
const permissionID = api[permission];
|
|
if (typeof permissionID !== "string")
|
|
throw new Error("Invalid permission name");
|
|
return permissionID
|
|
}
|
|
_HasPermission(id) {
|
|
const api = this._GetPermissionAPI();
|
|
return new Promise((resolve,reject)=>api["checkPermission"](this._MapPermissionID(api, id), status=>resolve(!!status["hasPermission"]), reject))
|
|
}
|
|
_RequestPermission(id) {
|
|
const api = this._GetPermissionAPI();
|
|
return new Promise((resolve,reject)=>api["requestPermission"](this._MapPermissionID(api, id), status=>resolve(!!status["hasPermission"]), reject))
|
|
}
|
|
async RequestPermissions(permissions) {
|
|
if (this.GetExportType() !== "cordova")
|
|
return true;
|
|
if (this.IsiOSCordova())
|
|
return true;
|
|
for (const id of permissions) {
|
|
const alreadyGranted = await this._HasPermission(id);
|
|
if (alreadyGranted)
|
|
continue;
|
|
const granted = await this._RequestPermission(id);
|
|
if (granted === false)
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
async RequirePermissions(...permissions) {
|
|
if (await this.RequestPermissions(permissions) === false)
|
|
throw new Error("Permission not granted");
|
|
}
|
|
CordovaFetchLocalFile(filename) {
|
|
const path = window["cordova"]["file"]["applicationDirectory"] + "www/" + filename.toLowerCase();
|
|
return new Promise((resolve,reject)=>{
|
|
window["resolveLocalFileSystemURL"](path, entry=>{
|
|
entry["file"](resolve, reject)
|
|
}
|
|
, reject)
|
|
}
|
|
)
|
|
}
|
|
async CordovaFetchLocalFileAsText(filename) {
|
|
const file = await this.CordovaFetchLocalFile(filename);
|
|
return await BlobToString(file)
|
|
}
|
|
_CordovaMaybeStartNextArrayBufferRead() {
|
|
if (!queuedArrayBufferReads.length)
|
|
return;
|
|
if (activeArrayBufferReads >= MAX_ARRAYBUFFER_READS)
|
|
return;
|
|
activeArrayBufferReads++;
|
|
const job = queuedArrayBufferReads.shift();
|
|
this._CordovaDoFetchLocalFileAsAsArrayBuffer(job.filename, job.successCallback, job.errorCallback)
|
|
}
|
|
CordovaFetchLocalFileAsArrayBuffer(filename) {
|
|
return new Promise((resolve,reject)=>{
|
|
queuedArrayBufferReads.push({
|
|
filename: filename,
|
|
successCallback: result=>{
|
|
activeArrayBufferReads--;
|
|
this._CordovaMaybeStartNextArrayBufferRead();
|
|
resolve(result)
|
|
}
|
|
,
|
|
errorCallback: err=>{
|
|
activeArrayBufferReads--;
|
|
this._CordovaMaybeStartNextArrayBufferRead();
|
|
reject(err)
|
|
}
|
|
});
|
|
this._CordovaMaybeStartNextArrayBufferRead()
|
|
}
|
|
)
|
|
}
|
|
async _CordovaDoFetchLocalFileAsAsArrayBuffer(filename, successCallback, errorCallback) {
|
|
try {
|
|
const file = await this.CordovaFetchLocalFile(filename);
|
|
const arrayBuffer = await BlobToArrayBuffer(file);
|
|
successCallback(arrayBuffer)
|
|
} catch (err) {
|
|
errorCallback(err)
|
|
}
|
|
}
|
|
async _ConvertDataUrisToBlobs() {
|
|
const promises = [];
|
|
for (const [filename,data] of Object.entries(this._localFileBlobs))
|
|
promises.push(this._ConvertDataUriToBlobs(filename, data));
|
|
await Promise.all(promises)
|
|
}
|
|
async _ConvertDataUriToBlobs(filename, data) {
|
|
if (typeof data === "object") {
|
|
this._localFileBlobs[filename] = new Blob([data["str"]],{
|
|
"type": data["type"]
|
|
});
|
|
this._localFileStrings[filename] = data["str"]
|
|
} else {
|
|
let blob = await this._FetchDataUri(data);
|
|
if (!blob)
|
|
blob = this._DataURIToBinaryBlobSync(data);
|
|
this._localFileBlobs[filename] = blob
|
|
}
|
|
}
|
|
async _FetchDataUri(dataUri) {
|
|
try {
|
|
const response = await fetch(dataUri);
|
|
return await response.blob()
|
|
} catch (err) {
|
|
console.warn("Failed to fetch a data: URI. Falling back to a slower workaround. This is probably because the Content Security Policy unnecessarily blocked it. Allow data: URIs in your CSP to avoid this.", err);
|
|
return null
|
|
}
|
|
}
|
|
_DataURIToBinaryBlobSync(datauri) {
|
|
const o = this._ParseDataURI(datauri);
|
|
return this._BinaryStringToBlob(o.data, o.mime_type)
|
|
}
|
|
_ParseDataURI(datauri) {
|
|
const comma = datauri.indexOf(",");
|
|
if (comma < 0)
|
|
throw new URIError("expected comma in data: uri");
|
|
const typepart = datauri.substring(5, comma);
|
|
const datapart = datauri.substring(comma + 1);
|
|
const typearr = typepart.split(";");
|
|
const mimetype = typearr[0] || "";
|
|
const encoding1 = typearr[1];
|
|
const encoding2 = typearr[2];
|
|
let decodeddata;
|
|
if (encoding1 === "base64" || encoding2 === "base64")
|
|
decodeddata = atob(datapart);
|
|
else
|
|
decodeddata = decodeURIComponent(datapart);
|
|
return {
|
|
mime_type: mimetype,
|
|
data: decodeddata
|
|
}
|
|
}
|
|
_BinaryStringToBlob(binstr, mime_type) {
|
|
let len = binstr.length;
|
|
let len32 = len >> 2;
|
|
let a8 = new Uint8Array(len);
|
|
let a32 = new Uint32Array(a8.buffer,0,len32);
|
|
let i, j;
|
|
for (i = 0,
|
|
j = 0; i < len32; ++i)
|
|
a32[i] = binstr.charCodeAt(j++) | binstr.charCodeAt(j++) << 8 | binstr.charCodeAt(j++) << 16 | binstr.charCodeAt(j++) << 24;
|
|
let tailLength = len & 3;
|
|
while (tailLength--) {
|
|
a8[j] = binstr.charCodeAt(j);
|
|
++j
|
|
}
|
|
return new Blob([a8],{
|
|
"type": mime_type
|
|
})
|
|
}
|
|
}
|
|
}
|
|
;'use strict';
|
|
{
|
|
const RuntimeInterface = self.RuntimeInterface;
|
|
function IsCompatibilityMouseEvent(e) {
|
|
return e["sourceCapabilities"] && e["sourceCapabilities"]["firesTouchEvents"] || e["originalEvent"] && e["originalEvent"]["sourceCapabilities"] && e["originalEvent"]["sourceCapabilities"]["firesTouchEvents"]
|
|
}
|
|
const KEY_CODE_ALIASES = new Map([["OSLeft", "MetaLeft"], ["OSRight", "MetaRight"]]);
|
|
const DISPATCH_RUNTIME_AND_SCRIPT = {
|
|
"dispatchRuntimeEvent": true,
|
|
"dispatchUserScriptEvent": true
|
|
};
|
|
const DISPATCH_SCRIPT_ONLY = {
|
|
"dispatchUserScriptEvent": true
|
|
};
|
|
const DISPATCH_RUNTIME_ONLY = {
|
|
"dispatchRuntimeEvent": true
|
|
};
|
|
function AddStyleSheet(cssUrl) {
|
|
return new Promise((resolve,reject)=>{
|
|
const styleLink = document.createElement("link");
|
|
styleLink.onload = ()=>resolve(styleLink);
|
|
styleLink.onerror = err=>reject(err);
|
|
styleLink.rel = "stylesheet";
|
|
styleLink.href = cssUrl;
|
|
document.head.appendChild(styleLink)
|
|
}
|
|
)
|
|
}
|
|
function FetchImage(url) {
|
|
return new Promise((resolve,reject)=>{
|
|
const img = new Image;
|
|
img.onload = ()=>resolve(img);
|
|
img.onerror = err=>reject(err);
|
|
img.src = url
|
|
}
|
|
)
|
|
}
|
|
async function BlobToImage(blob) {
|
|
const blobUrl = URL.createObjectURL(blob);
|
|
try {
|
|
return await FetchImage(blobUrl)
|
|
} finally {
|
|
URL.revokeObjectURL(blobUrl)
|
|
}
|
|
}
|
|
function BlobToString(blob) {
|
|
return new Promise((resolve,reject)=>{
|
|
let fileReader = new FileReader;
|
|
fileReader.onload = e=>resolve(e.target.result);
|
|
fileReader.onerror = err=>reject(err);
|
|
fileReader.readAsText(blob)
|
|
}
|
|
)
|
|
}
|
|
async function BlobToSvgImage(blob, width, height) {
|
|
if (!/firefox/i.test(navigator.userAgent))
|
|
return await BlobToImage(blob);
|
|
let str = await BlobToString(blob);
|
|
const parser = new DOMParser;
|
|
const doc = parser.parseFromString(str, "image/svg+xml");
|
|
const rootElem = doc.documentElement;
|
|
if (rootElem.hasAttribute("width") && rootElem.hasAttribute("height")) {
|
|
const widthStr = rootElem.getAttribute("width");
|
|
const heightStr = rootElem.getAttribute("height");
|
|
if (!widthStr.includes("%") && !heightStr.includes("%"))
|
|
return await BlobToImage(blob)
|
|
}
|
|
rootElem.setAttribute("width", width + "px");
|
|
rootElem.setAttribute("height", height + "px");
|
|
const serializer = new XMLSerializer;
|
|
str = serializer.serializeToString(doc);
|
|
blob = new Blob([str],{
|
|
type: "image/svg+xml"
|
|
});
|
|
return await BlobToImage(blob)
|
|
}
|
|
function IsInContentEditable(el) {
|
|
do {
|
|
if (el.parentNode && el.hasAttribute("contenteditable"))
|
|
return true;
|
|
el = el.parentNode
|
|
} while (el);
|
|
return false
|
|
}
|
|
const canvasOrDocTags = new Set(["canvas", "body", "html"]);
|
|
function PreventDefaultOnCanvasOrDoc(e) {
|
|
const tagName = e.target.tagName.toLowerCase();
|
|
if (canvasOrDocTags.has(tagName))
|
|
e.preventDefault()
|
|
}
|
|
function BlockWheelZoom(e) {
|
|
if (e.metaKey || e.ctrlKey)
|
|
e.preventDefault()
|
|
}
|
|
self["C3_GetSvgImageSize"] = async function(blob) {
|
|
const img = await BlobToImage(blob);
|
|
if (img.width > 0 && img.height > 0)
|
|
return [img.width, img.height];
|
|
else {
|
|
img.style.position = "absolute";
|
|
img.style.left = "0px";
|
|
img.style.top = "0px";
|
|
img.style.visibility = "hidden";
|
|
document.body.appendChild(img);
|
|
const rc = img.getBoundingClientRect();
|
|
document.body.removeChild(img);
|
|
return [rc.width, rc.height]
|
|
}
|
|
}
|
|
;
|
|
self["C3_RasterSvgImageBlob"] = async function(blob, imageWidth, imageHeight, surfaceWidth, surfaceHeight) {
|
|
const img = await BlobToSvgImage(blob, imageWidth, imageHeight);
|
|
const canvas = document.createElement("canvas");
|
|
canvas.width = surfaceWidth;
|
|
canvas.height = surfaceHeight;
|
|
const ctx = canvas.getContext("2d");
|
|
ctx.drawImage(img, 0, 0, imageWidth, imageHeight);
|
|
return canvas
|
|
}
|
|
;
|
|
let isCordovaPaused = false;
|
|
document.addEventListener("pause", ()=>isCordovaPaused = true);
|
|
document.addEventListener("resume", ()=>isCordovaPaused = false);
|
|
function ParentHasFocus() {
|
|
try {
|
|
return window.parent && window.parent.document.hasFocus()
|
|
} catch (err) {
|
|
return false
|
|
}
|
|
}
|
|
function KeyboardIsVisible() {
|
|
const elem = document.activeElement;
|
|
if (!elem)
|
|
return false;
|
|
const tagName = elem.tagName.toLowerCase();
|
|
const inputTypes = new Set(["email", "number", "password", "search", "tel", "text", "url"]);
|
|
if (tagName === "textarea")
|
|
return true;
|
|
if (tagName === "input")
|
|
return inputTypes.has(elem.type.toLowerCase() || "text");
|
|
return IsInContentEditable(elem)
|
|
}
|
|
const DOM_COMPONENT_ID = "runtime";
|
|
const HANDLER_CLASS = class RuntimeDOMHandler extends self.DOMHandler {
|
|
constructor(iRuntime) {
|
|
super(iRuntime, DOM_COMPONENT_ID);
|
|
this._isFirstSizeUpdate = true;
|
|
this._simulatedResizeTimerId = -1;
|
|
this._targetOrientation = "any";
|
|
this._attachedDeviceOrientationEvent = false;
|
|
this._attachedDeviceMotionEvent = false;
|
|
this._debugHighlightElem = null;
|
|
this._pointerRawUpdateRateLimiter = null;
|
|
this._lastPointerRawUpdateEvent = null;
|
|
iRuntime.AddRuntimeComponentMessageHandler("canvas", "update-size", e=>this._OnUpdateCanvasSize(e));
|
|
iRuntime.AddRuntimeComponentMessageHandler("runtime", "invoke-download", e=>this._OnInvokeDownload(e));
|
|
iRuntime.AddRuntimeComponentMessageHandler("runtime", "raster-svg-image", e=>this._OnRasterSvgImage(e));
|
|
iRuntime.AddRuntimeComponentMessageHandler("runtime", "get-svg-image-size", e=>this._OnGetSvgImageSize(e));
|
|
iRuntime.AddRuntimeComponentMessageHandler("runtime", "set-target-orientation", e=>this._OnSetTargetOrientation(e));
|
|
iRuntime.AddRuntimeComponentMessageHandler("runtime", "register-sw", ()=>this._OnRegisterSW());
|
|
iRuntime.AddRuntimeComponentMessageHandler("runtime", "post-to-debugger", e=>this._OnPostToDebugger(e));
|
|
iRuntime.AddRuntimeComponentMessageHandler("runtime", "go-to-script", e=>this._OnPostToDebugger(e));
|
|
iRuntime.AddRuntimeComponentMessageHandler("runtime", "before-start-ticking", ()=>this._OnBeforeStartTicking());
|
|
iRuntime.AddRuntimeComponentMessageHandler("runtime", "debug-highlight", e=>this._OnDebugHighlight(e));
|
|
iRuntime.AddRuntimeComponentMessageHandler("runtime", "enable-device-orientation", ()=>this._AttachDeviceOrientationEvent());
|
|
iRuntime.AddRuntimeComponentMessageHandler("runtime", "enable-device-motion", ()=>this._AttachDeviceMotionEvent());
|
|
iRuntime.AddRuntimeComponentMessageHandler("runtime", "add-stylesheet", e=>this._OnAddStylesheet(e));
|
|
iRuntime.AddRuntimeComponentMessageHandler("runtime", "alert", e=>this._OnAlert(e));
|
|
iRuntime.AddRuntimeComponentMessageHandler("runtime", "hide-cordova-splash", ()=>this._OnHideCordovaSplash());
|
|
const allowDefaultContextMenuTagNames = new Set(["input", "textarea", "datalist"]);
|
|
window.addEventListener("contextmenu", e=>{
|
|
const t = e.target;
|
|
const name = t.tagName.toLowerCase();
|
|
if (!allowDefaultContextMenuTagNames.has(name) && !IsInContentEditable(t))
|
|
e.preventDefault()
|
|
}
|
|
);
|
|
const canvas = iRuntime.GetCanvas();
|
|
window.addEventListener("selectstart", PreventDefaultOnCanvasOrDoc);
|
|
window.addEventListener("gesturehold", PreventDefaultOnCanvasOrDoc);
|
|
canvas.addEventListener("selectstart", PreventDefaultOnCanvasOrDoc);
|
|
canvas.addEventListener("gesturehold", PreventDefaultOnCanvasOrDoc);
|
|
window.addEventListener("touchstart", PreventDefaultOnCanvasOrDoc, {
|
|
"passive": false
|
|
});
|
|
if (typeof PointerEvent !== "undefined") {
|
|
window.addEventListener("pointerdown", PreventDefaultOnCanvasOrDoc, {
|
|
"passive": false
|
|
});
|
|
canvas.addEventListener("pointerdown", PreventDefaultOnCanvasOrDoc)
|
|
} else
|
|
canvas.addEventListener("touchstart", PreventDefaultOnCanvasOrDoc);
|
|
this._mousePointerLastButtons = 0;
|
|
window.addEventListener("mousedown", e=>{
|
|
if (e.button === 1)
|
|
e.preventDefault()
|
|
}
|
|
);
|
|
window.addEventListener("mousewheel", BlockWheelZoom, {
|
|
"passive": false
|
|
});
|
|
window.addEventListener("wheel", BlockWheelZoom, {
|
|
"passive": false
|
|
});
|
|
window.addEventListener("resize", ()=>this._OnWindowResize());
|
|
if (iRuntime.IsiOSWebView())
|
|
window.addEventListener("focusout", ()=>{
|
|
if (!KeyboardIsVisible())
|
|
document.scrollingElement.scrollTop = 0
|
|
}
|
|
);
|
|
this._mediaPendingPlay = new Set;
|
|
this._mediaRemovedPendingPlay = new WeakSet;
|
|
this._isSilent = false
|
|
}
|
|
_OnBeforeStartTicking() {
|
|
if (this._iRuntime.GetExportType() === "cordova") {
|
|
document.addEventListener("pause", ()=>this._OnVisibilityChange(true));
|
|
document.addEventListener("resume", ()=>this._OnVisibilityChange(false))
|
|
} else
|
|
document.addEventListener("visibilitychange", ()=>this._OnVisibilityChange(document.hidden));
|
|
return {
|
|
"isSuspended": !!(document.hidden || isCordovaPaused)
|
|
}
|
|
}
|
|
Attach() {
|
|
window.addEventListener("focus", ()=>this._PostRuntimeEvent("window-focus"));
|
|
window.addEventListener("blur", ()=>{
|
|
this._PostRuntimeEvent("window-blur", {
|
|
"parentHasFocus": ParentHasFocus()
|
|
});
|
|
this._mousePointerLastButtons = 0
|
|
}
|
|
);
|
|
window.addEventListener("fullscreenchange", ()=>this._OnFullscreenChange());
|
|
window.addEventListener("webkitfullscreenchange", ()=>this._OnFullscreenChange());
|
|
window.addEventListener("mozfullscreenchange", ()=>this._OnFullscreenChange());
|
|
window.addEventListener("fullscreenerror", e=>this._OnFullscreenError(e));
|
|
window.addEventListener("webkitfullscreenerror", e=>this._OnFullscreenError(e));
|
|
window.addEventListener("mozfullscreenerror", e=>this._OnFullscreenError(e));
|
|
window.addEventListener("keydown", e=>this._OnKeyEvent("keydown", e));
|
|
window.addEventListener("keyup", e=>this._OnKeyEvent("keyup", e));
|
|
window.addEventListener("dblclick", e=>this._OnMouseEvent("dblclick", e, DISPATCH_RUNTIME_AND_SCRIPT));
|
|
window.addEventListener("wheel", e=>this._OnMouseWheelEvent("wheel", e));
|
|
if (typeof PointerEvent !== "undefined") {
|
|
window.addEventListener("pointerdown", e=>{
|
|
this._HandlePointerDownFocus(e);
|
|
this._OnPointerEvent("pointerdown", e)
|
|
}
|
|
);
|
|
if (this._iRuntime.UsesWorker() && typeof window["onpointerrawupdate"] !== "undefined" && self === self.top) {
|
|
this._pointerRawUpdateRateLimiter = new self.RateLimiter(()=>this._DoSendPointerRawUpdate(),5);
|
|
this._pointerRawUpdateRateLimiter.SetCanRunImmediate(true);
|
|
window.addEventListener("pointerrawupdate", e=>this._OnPointerRawUpdate(e))
|
|
} else
|
|
window.addEventListener("pointermove", e=>this._OnPointerEvent("pointermove", e));
|
|
window.addEventListener("pointerup", e=>this._OnPointerEvent("pointerup", e));
|
|
window.addEventListener("pointercancel", e=>this._OnPointerEvent("pointercancel", e))
|
|
} else {
|
|
window.addEventListener("mousedown", e=>{
|
|
this._HandlePointerDownFocus(e);
|
|
this._OnMouseEventAsPointer("pointerdown", e)
|
|
}
|
|
);
|
|
window.addEventListener("mousemove", e=>this._OnMouseEventAsPointer("pointermove", e));
|
|
window.addEventListener("mouseup", e=>this._OnMouseEventAsPointer("pointerup", e));
|
|
window.addEventListener("touchstart", e=>{
|
|
this._HandlePointerDownFocus(e);
|
|
this._OnTouchEvent("pointerdown", e)
|
|
}
|
|
);
|
|
window.addEventListener("touchmove", e=>this._OnTouchEvent("pointermove", e));
|
|
window.addEventListener("touchend", e=>this._OnTouchEvent("pointerup", e));
|
|
window.addEventListener("touchcancel", e=>this._OnTouchEvent("pointercancel", e))
|
|
}
|
|
const playFunc = ()=>this._PlayPendingMedia();
|
|
window.addEventListener("pointerup", playFunc, true);
|
|
window.addEventListener("touchend", playFunc, true);
|
|
window.addEventListener("click", playFunc, true);
|
|
window.addEventListener("keydown", playFunc, true);
|
|
window.addEventListener("gamepadconnected", playFunc, true)
|
|
}
|
|
_PostRuntimeEvent(name, data) {
|
|
this.PostToRuntime(name, data || null, DISPATCH_RUNTIME_ONLY)
|
|
}
|
|
_GetWindowInnerWidth() {
|
|
return this._iRuntime._GetWindowInnerWidth()
|
|
}
|
|
_GetWindowInnerHeight() {
|
|
return this._iRuntime._GetWindowInnerHeight()
|
|
}
|
|
_OnWindowResize() {
|
|
const width = this._GetWindowInnerWidth();
|
|
const height = this._GetWindowInnerHeight();
|
|
this._PostRuntimeEvent("window-resize", {
|
|
"innerWidth": width,
|
|
"innerHeight": height,
|
|
"devicePixelRatio": window.devicePixelRatio
|
|
});
|
|
if (this._iRuntime.IsiOSWebView()) {
|
|
if (this._simulatedResizeTimerId !== -1)
|
|
clearTimeout(this._simulatedResizeTimerId);
|
|
this._OnSimulatedResize(width, height, 0)
|
|
}
|
|
}
|
|
_ScheduleSimulatedResize(width, height, count) {
|
|
if (this._simulatedResizeTimerId !== -1)
|
|
clearTimeout(this._simulatedResizeTimerId);
|
|
this._simulatedResizeTimerId = setTimeout(()=>this._OnSimulatedResize(width, height, count), 48)
|
|
}
|
|
_OnSimulatedResize(originalWidth, originalHeight, count) {
|
|
const width = this._GetWindowInnerWidth();
|
|
const height = this._GetWindowInnerHeight();
|
|
this._simulatedResizeTimerId = -1;
|
|
if (width != originalWidth || height != originalHeight)
|
|
this._PostRuntimeEvent("window-resize", {
|
|
"innerWidth": width,
|
|
"innerHeight": height,
|
|
"devicePixelRatio": window.devicePixelRatio
|
|
});
|
|
else if (count < 10)
|
|
this._ScheduleSimulatedResize(width, height, count + 1)
|
|
}
|
|
_OnSetTargetOrientation(e) {
|
|
this._targetOrientation = e["targetOrientation"]
|
|
}
|
|
_TrySetTargetOrientation() {
|
|
const orientation = this._targetOrientation;
|
|
if (screen["orientation"] && screen["orientation"]["lock"])
|
|
screen["orientation"]["lock"](orientation).catch(err=>console.warn("[Construct 3] Failed to lock orientation: ", err));
|
|
else
|
|
try {
|
|
let result = false;
|
|
if (screen["lockOrientation"])
|
|
result = screen["lockOrientation"](orientation);
|
|
else if (screen["webkitLockOrientation"])
|
|
result = screen["webkitLockOrientation"](orientation);
|
|
else if (screen["mozLockOrientation"])
|
|
result = screen["mozLockOrientation"](orientation);
|
|
else if (screen["msLockOrientation"])
|
|
result = screen["msLockOrientation"](orientation);
|
|
if (!result)
|
|
console.warn("[Construct 3] Failed to lock orientation")
|
|
} catch (err) {
|
|
console.warn("[Construct 3] Failed to lock orientation: ", err)
|
|
}
|
|
}
|
|
_OnFullscreenChange() {
|
|
const isDocFullscreen = RuntimeInterface.IsDocumentFullscreen();
|
|
if (isDocFullscreen && this._targetOrientation !== "any")
|
|
this._TrySetTargetOrientation();
|
|
this.PostToRuntime("fullscreenchange", {
|
|
"isFullscreen": isDocFullscreen,
|
|
"innerWidth": this._GetWindowInnerWidth(),
|
|
"innerHeight": this._GetWindowInnerHeight()
|
|
})
|
|
}
|
|
_OnFullscreenError(e) {
|
|
console.warn("[Construct 3] Fullscreen request failed: ", e);
|
|
this.PostToRuntime("fullscreenerror", {
|
|
"isFullscreen": RuntimeInterface.IsDocumentFullscreen(),
|
|
"innerWidth": this._GetWindowInnerWidth(),
|
|
"innerHeight": this._GetWindowInnerHeight()
|
|
})
|
|
}
|
|
_OnVisibilityChange(isHidden) {
|
|
if (isHidden)
|
|
this._iRuntime._CancelAnimationFrame();
|
|
else
|
|
this._iRuntime._RequestAnimationFrame();
|
|
this.PostToRuntime("visibilitychange", {
|
|
"hidden": isHidden
|
|
})
|
|
}
|
|
_OnKeyEvent(name, e) {
|
|
if (e.key === "Backspace")
|
|
PreventDefaultOnCanvasOrDoc(e);
|
|
const code = KEY_CODE_ALIASES.get(e.code) || e.code;
|
|
this._PostToRuntimeMaybeSync(name, {
|
|
"code": code,
|
|
"key": e.key,
|
|
"which": e.which,
|
|
"repeat": e.repeat,
|
|
"altKey": e.altKey,
|
|
"ctrlKey": e.ctrlKey,
|
|
"metaKey": e.metaKey,
|
|
"shiftKey": e.shiftKey,
|
|
"timeStamp": e.timeStamp
|
|
}, DISPATCH_RUNTIME_AND_SCRIPT)
|
|
}
|
|
_OnMouseWheelEvent(name, e) {
|
|
this.PostToRuntime(name, {
|
|
"clientX": e.clientX,
|
|
"clientY": e.clientY,
|
|
"pageX": e.pageX,
|
|
"pageY": e.pageY,
|
|
"deltaX": e.deltaX,
|
|
"deltaY": e.deltaY,
|
|
"deltaZ": e.deltaZ,
|
|
"deltaMode": e.deltaMode,
|
|
"timeStamp": e.timeStamp
|
|
}, DISPATCH_RUNTIME_AND_SCRIPT)
|
|
}
|
|
_OnMouseEvent(name, e, opts) {
|
|
if (IsCompatibilityMouseEvent(e))
|
|
return;
|
|
this._PostToRuntimeMaybeSync(name, {
|
|
"button": e.button,
|
|
"buttons": e.buttons,
|
|
"clientX": e.clientX,
|
|
"clientY": e.clientY,
|
|
"pageX": e.pageX,
|
|
"pageY": e.pageY,
|
|
"timeStamp": e.timeStamp
|
|
}, opts)
|
|
}
|
|
_OnMouseEventAsPointer(name, e) {
|
|
if (IsCompatibilityMouseEvent(e))
|
|
return;
|
|
const pointerId = 1;
|
|
const lastButtons = this._mousePointerLastButtons;
|
|
if (name === "pointerdown" && lastButtons !== 0)
|
|
name = "pointermove";
|
|
else if (name === "pointerup" && e.buttons !== 0)
|
|
name = "pointermove";
|
|
this._PostToRuntimeMaybeSync(name, {
|
|
"pointerId": pointerId,
|
|
"pointerType": "mouse",
|
|
"button": e.button,
|
|
"buttons": e.buttons,
|
|
"lastButtons": lastButtons,
|
|
"clientX": e.clientX,
|
|
"clientY": e.clientY,
|
|
"pageX": e.pageX,
|
|
"pageY": e.pageY,
|
|
"width": 0,
|
|
"height": 0,
|
|
"pressure": 0,
|
|
"tangentialPressure": 0,
|
|
"tiltX": 0,
|
|
"tiltY": 0,
|
|
"twist": 0,
|
|
"timeStamp": e.timeStamp
|
|
}, DISPATCH_RUNTIME_AND_SCRIPT);
|
|
this._mousePointerLastButtons = e.buttons;
|
|
this._OnMouseEvent(e.type, e, DISPATCH_SCRIPT_ONLY)
|
|
}
|
|
_OnPointerEvent(name, e) {
|
|
if (this._pointerRawUpdateRateLimiter && name !== "pointermove")
|
|
this._pointerRawUpdateRateLimiter.Reset();
|
|
let lastButtons = 0;
|
|
if (e.pointerType === "mouse")
|
|
lastButtons = this._mousePointerLastButtons;
|
|
this._PostToRuntimeMaybeSync(name, {
|
|
"pointerId": e.pointerId,
|
|
"pointerType": e.pointerType,
|
|
"button": e.button,
|
|
"buttons": e.buttons,
|
|
"lastButtons": lastButtons,
|
|
"clientX": e.clientX,
|
|
"clientY": e.clientY,
|
|
"pageX": e.pageX,
|
|
"pageY": e.pageY,
|
|
"width": e.width || 0,
|
|
"height": e.height || 0,
|
|
"pressure": e.pressure || 0,
|
|
"tangentialPressure": e["tangentialPressure"] || 0,
|
|
"tiltX": e.tiltX || 0,
|
|
"tiltY": e.tiltY || 0,
|
|
"twist": e["twist"] || 0,
|
|
"timeStamp": e.timeStamp
|
|
}, DISPATCH_RUNTIME_AND_SCRIPT);
|
|
if (e.pointerType === "mouse") {
|
|
let mouseEventName = "mousemove";
|
|
if (name === "pointerdown")
|
|
mouseEventName = "mousedown";
|
|
else if (name === "pointerup")
|
|
mouseEventName = "pointerup";
|
|
this._OnMouseEvent(mouseEventName, e, DISPATCH_SCRIPT_ONLY);
|
|
this._mousePointerLastButtons = e.buttons
|
|
}
|
|
}
|
|
_OnPointerRawUpdate(e) {
|
|
this._lastPointerRawUpdateEvent = e;
|
|
this._pointerRawUpdateRateLimiter.Call()
|
|
}
|
|
_DoSendPointerRawUpdate() {
|
|
this._OnPointerEvent("pointermove", this._lastPointerRawUpdateEvent);
|
|
this._lastPointerRawUpdateEvent = null
|
|
}
|
|
_OnTouchEvent(fireName, e) {
|
|
for (let i = 0, len = e.changedTouches.length; i < len; ++i) {
|
|
const t = e.changedTouches[i];
|
|
this._PostToRuntimeMaybeSync(fireName, {
|
|
"pointerId": t.identifier,
|
|
"pointerType": "touch",
|
|
"button": 0,
|
|
"buttons": 0,
|
|
"lastButtons": 0,
|
|
"clientX": t.clientX,
|
|
"clientY": t.clientY,
|
|
"pageX": t.pageX,
|
|
"pageY": t.pageY,
|
|
"width": (t["radiusX"] || t["webkitRadiusX"] || 0) * 2,
|
|
"height": (t["radiusY"] || t["webkitRadiusY"] || 0) * 2,
|
|
"pressure": t["force"] || t["webkitForce"] || 0,
|
|
"tangentialPressure": 0,
|
|
"tiltX": 0,
|
|
"tiltY": 0,
|
|
"twist": t["rotationAngle"] || 0,
|
|
"timeStamp": e.timeStamp
|
|
}, DISPATCH_RUNTIME_AND_SCRIPT)
|
|
}
|
|
}
|
|
_HandlePointerDownFocus(e) {
|
|
if (window !== window.top)
|
|
window.focus();
|
|
if (this._IsElementCanvasOrDocument(e.target) && document.activeElement && !this._IsElementCanvasOrDocument(document.activeElement))
|
|
document.activeElement.blur()
|
|
}
|
|
_IsElementCanvasOrDocument(elem) {
|
|
return !elem || elem === document || elem === window || elem === document.body || elem.tagName.toLowerCase() === "canvas"
|
|
}
|
|
_AttachDeviceOrientationEvent() {
|
|
if (this._attachedDeviceOrientationEvent)
|
|
return;
|
|
this._attachedDeviceOrientationEvent = true;
|
|
window.addEventListener("deviceorientation", e=>this._OnDeviceOrientation(e));
|
|
window.addEventListener("deviceorientationabsolute", e=>this._OnDeviceOrientationAbsolute(e))
|
|
}
|
|
_AttachDeviceMotionEvent() {
|
|
if (this._attachedDeviceMotionEvent)
|
|
return;
|
|
this._attachedDeviceMotionEvent = true;
|
|
window.addEventListener("devicemotion", e=>this._OnDeviceMotion(e))
|
|
}
|
|
_OnDeviceOrientation(e) {
|
|
this.PostToRuntime("deviceorientation", {
|
|
"absolute": !!e["absolute"],
|
|
"alpha": e["alpha"] || 0,
|
|
"beta": e["beta"] || 0,
|
|
"gamma": e["gamma"] || 0,
|
|
"timeStamp": e.timeStamp,
|
|
"webkitCompassHeading": e["webkitCompassHeading"],
|
|
"webkitCompassAccuracy": e["webkitCompassAccuracy"]
|
|
}, DISPATCH_RUNTIME_AND_SCRIPT)
|
|
}
|
|
_OnDeviceOrientationAbsolute(e) {
|
|
this.PostToRuntime("deviceorientationabsolute", {
|
|
"absolute": !!e["absolute"],
|
|
"alpha": e["alpha"] || 0,
|
|
"beta": e["beta"] || 0,
|
|
"gamma": e["gamma"] || 0,
|
|
"timeStamp": e.timeStamp
|
|
}, DISPATCH_RUNTIME_AND_SCRIPT)
|
|
}
|
|
_OnDeviceMotion(e) {
|
|
let accProp = null;
|
|
const acc = e["acceleration"];
|
|
if (acc)
|
|
accProp = {
|
|
"x": acc["x"] || 0,
|
|
"y": acc["y"] || 0,
|
|
"z": acc["z"] || 0
|
|
};
|
|
let withGProp = null;
|
|
const withG = e["accelerationIncludingGravity"];
|
|
if (withG)
|
|
withGProp = {
|
|
"x": withG["x"] || 0,
|
|
"y": withG["y"] || 0,
|
|
"z": withG["z"] || 0
|
|
};
|
|
let rotationRateProp = null;
|
|
const rotationRate = e["rotationRate"];
|
|
if (rotationRate)
|
|
rotationRateProp = {
|
|
"alpha": rotationRate["alpha"] || 0,
|
|
"beta": rotationRate["beta"] || 0,
|
|
"gamma": rotationRate["gamma"] || 0
|
|
};
|
|
this.PostToRuntime("devicemotion", {
|
|
"acceleration": accProp,
|
|
"accelerationIncludingGravity": withGProp,
|
|
"rotationRate": rotationRateProp,
|
|
"interval": e["interval"],
|
|
"timeStamp": e.timeStamp
|
|
}, DISPATCH_RUNTIME_AND_SCRIPT)
|
|
}
|
|
_OnUpdateCanvasSize(e) {
|
|
const runtimeInterface = this.GetRuntimeInterface();
|
|
const canvas = runtimeInterface.GetCanvas();
|
|
canvas.style.width = e["styleWidth"] + "px";
|
|
canvas.style.height = e["styleHeight"] + "px";
|
|
canvas.style.marginLeft = e["marginLeft"] + "px";
|
|
canvas.style.marginTop = e["marginTop"] + "px";
|
|
runtimeInterface.MaybeForceBodySize();
|
|
if (this._isFirstSizeUpdate) {
|
|
canvas.style.display = "";
|
|
this._isFirstSizeUpdate = false
|
|
}
|
|
}
|
|
_OnInvokeDownload(e) {
|
|
const url = e["url"];
|
|
const filename = e["filename"];
|
|
const a = document.createElement("a");
|
|
const body = document.body;
|
|
a.textContent = filename;
|
|
a.href = url;
|
|
a.download = filename;
|
|
body.appendChild(a);
|
|
a.click();
|
|
body.removeChild(a)
|
|
}
|
|
async _OnRasterSvgImage(e) {
|
|
const blob = e["blob"];
|
|
const imageWidth = e["imageWidth"];
|
|
const imageHeight = e["imageHeight"];
|
|
const surfaceWidth = e["surfaceWidth"];
|
|
const surfaceHeight = e["surfaceHeight"];
|
|
const imageBitmapOpts = e["imageBitmapOpts"];
|
|
const canvas = await self["C3_RasterSvgImageBlob"](blob, imageWidth, imageHeight, surfaceWidth, surfaceHeight);
|
|
let ret;
|
|
if (imageBitmapOpts)
|
|
ret = await createImageBitmap(canvas, imageBitmapOpts);
|
|
else
|
|
ret = await createImageBitmap(canvas);
|
|
return {
|
|
"imageBitmap": ret,
|
|
"transferables": [ret]
|
|
}
|
|
}
|
|
async _OnGetSvgImageSize(e) {
|
|
return await self["C3_GetSvgImageSize"](e["blob"])
|
|
}
|
|
async _OnAddStylesheet(e) {
|
|
await AddStyleSheet(e["url"])
|
|
}
|
|
_PlayPendingMedia() {
|
|
const mediaToTryPlay = [...this._mediaPendingPlay];
|
|
this._mediaPendingPlay.clear();
|
|
if (!this._isSilent)
|
|
for (const mediaElem of mediaToTryPlay) {
|
|
const playRet = mediaElem.play();
|
|
if (playRet)
|
|
playRet.catch(err=>{
|
|
if (!this._mediaRemovedPendingPlay.has(mediaElem))
|
|
this._mediaPendingPlay.add(mediaElem)
|
|
}
|
|
)
|
|
}
|
|
}
|
|
TryPlayMedia(mediaElem) {
|
|
if (typeof mediaElem.play !== "function")
|
|
throw new Error("missing play function");
|
|
this._mediaRemovedPendingPlay.delete(mediaElem);
|
|
let playRet;
|
|
try {
|
|
playRet = mediaElem.play()
|
|
} catch (err) {
|
|
this._mediaPendingPlay.add(mediaElem);
|
|
return
|
|
}
|
|
if (playRet)
|
|
playRet.catch(err=>{
|
|
if (!this._mediaRemovedPendingPlay.has(mediaElem))
|
|
this._mediaPendingPlay.add(mediaElem)
|
|
}
|
|
)
|
|
}
|
|
RemovePendingPlay(mediaElem) {
|
|
this._mediaPendingPlay.delete(mediaElem);
|
|
this._mediaRemovedPendingPlay.add(mediaElem)
|
|
}
|
|
SetSilent(s) {
|
|
this._isSilent = !!s
|
|
}
|
|
_OnHideCordovaSplash() {
|
|
if (navigator["splashscreen"] && navigator["splashscreen"]["hide"])
|
|
navigator["splashscreen"]["hide"]()
|
|
}
|
|
_OnDebugHighlight(e) {
|
|
const show = e["show"];
|
|
if (!show) {
|
|
if (this._debugHighlightElem)
|
|
this._debugHighlightElem.style.display = "none";
|
|
return
|
|
}
|
|
if (!this._debugHighlightElem) {
|
|
this._debugHighlightElem = document.createElement("div");
|
|
this._debugHighlightElem.id = "inspectOutline";
|
|
document.body.appendChild(this._debugHighlightElem)
|
|
}
|
|
const elem = this._debugHighlightElem;
|
|
elem.style.display = "";
|
|
elem.style.left = e["left"] - 1 + "px";
|
|
elem.style.top = e["top"] - 1 + "px";
|
|
elem.style.width = e["width"] + 2 + "px";
|
|
elem.style.height = e["height"] + 2 + "px";
|
|
elem.textContent = e["name"]
|
|
}
|
|
_OnRegisterSW() {
|
|
if (window["C3_RegisterSW"])
|
|
window["C3_RegisterSW"]()
|
|
}
|
|
_OnPostToDebugger(data) {
|
|
if (!window["c3_postToMessagePort"])
|
|
return;
|
|
data["from"] = "runtime";
|
|
window["c3_postToMessagePort"](data)
|
|
}
|
|
_InvokeFunctionFromJS(name, params) {
|
|
return this.PostToRuntimeAsync("js-invoke-function", {
|
|
"name": name,
|
|
"params": params
|
|
})
|
|
}
|
|
_OnAlert(e) {
|
|
alert(e["message"])
|
|
}
|
|
}
|
|
;
|
|
RuntimeInterface.AddDOMHandlerClass(HANDLER_CLASS)
|
|
}
|
|
;'use strict';
|
|
{
|
|
const DISPATCH_WORKER_SCRIPT_NAME = "dispatchworker.js";
|
|
const JOB_WORKER_SCRIPT_NAME = "jobworker.js";
|
|
self.JobSchedulerDOM = class JobSchedulerDOM {
|
|
constructor(runtimeInterface) {
|
|
this._runtimeInterface = runtimeInterface;
|
|
this._baseUrl = runtimeInterface.GetBaseURL();
|
|
if (runtimeInterface.GetExportType() === "preview")
|
|
this._baseUrl += "c3/workers/";
|
|
else
|
|
this._baseUrl += runtimeInterface.GetScriptFolder();
|
|
this._maxNumWorkers = Math.min(navigator.hardwareConcurrency || 2, 16);
|
|
this._dispatchWorker = null;
|
|
this._jobWorkers = [];
|
|
this._inputPort = null;
|
|
this._outputPort = null
|
|
}
|
|
async Init() {
|
|
if (this._hasInitialised)
|
|
throw new Error("already initialised");
|
|
this._hasInitialised = true;
|
|
const dispatchWorkerScriptUrl = this._runtimeInterface._GetWorkerURL(DISPATCH_WORKER_SCRIPT_NAME);
|
|
this._dispatchWorker = await this._runtimeInterface.CreateWorker(dispatchWorkerScriptUrl, this._baseUrl, {
|
|
name: "DispatchWorker"
|
|
});
|
|
const messageChannel = new MessageChannel;
|
|
this._inputPort = messageChannel.port1;
|
|
this._dispatchWorker.postMessage({
|
|
"type": "_init",
|
|
"in-port": messageChannel.port2
|
|
}, [messageChannel.port2]);
|
|
this._outputPort = await this._CreateJobWorker()
|
|
}
|
|
async _CreateJobWorker() {
|
|
const number = this._jobWorkers.length;
|
|
const jobWorkerScriptUrl = this._runtimeInterface._GetWorkerURL(JOB_WORKER_SCRIPT_NAME);
|
|
const jobWorker = await this._runtimeInterface.CreateWorker(jobWorkerScriptUrl, this._baseUrl, {
|
|
name: "JobWorker" + number
|
|
});
|
|
const dispatchChannel = new MessageChannel;
|
|
const outputChannel = new MessageChannel;
|
|
this._dispatchWorker.postMessage({
|
|
"type": "_addJobWorker",
|
|
"port": dispatchChannel.port1
|
|
}, [dispatchChannel.port1]);
|
|
jobWorker.postMessage({
|
|
"type": "init",
|
|
"number": number,
|
|
"dispatch-port": dispatchChannel.port2,
|
|
"output-port": outputChannel.port2
|
|
}, [dispatchChannel.port2, outputChannel.port2]);
|
|
this._jobWorkers.push(jobWorker);
|
|
return outputChannel.port1
|
|
}
|
|
GetPortData() {
|
|
return {
|
|
"inputPort": this._inputPort,
|
|
"outputPort": this._outputPort,
|
|
"maxNumWorkers": this._maxNumWorkers
|
|
}
|
|
}
|
|
GetPortTransferables() {
|
|
return [this._inputPort, this._outputPort]
|
|
}
|
|
}
|
|
}
|
|
;'use strict';
|
|
{
|
|
if (window["C3_IsSupported"]) {
|
|
const enableWorker = false;
|
|
window["c3_runtimeInterface"] = new self.RuntimeInterface({
|
|
useWorker: enableWorker,
|
|
workerMainUrl: "workermain.js",
|
|
engineScripts: ["scripts/c3runtime-f.js"],
|
|
scriptFolder: "scripts/",
|
|
workerDependencyScripts: [],
|
|
exportType: "html5"
|
|
})
|
|
}
|
|
}
|
|
;'use strict';
|
|
{
|
|
const DOM_COMPONENT_ID = "touch";
|
|
const HANDLER_CLASS = class TouchDOMHandler extends self.DOMHandler {
|
|
constructor(iRuntime) {
|
|
super(iRuntime, DOM_COMPONENT_ID);
|
|
this.AddRuntimeMessageHandler("request-permission", e=>this._OnRequestPermission(e))
|
|
}
|
|
async _OnRequestPermission(e) {
|
|
const type = e["type"];
|
|
let result = true;
|
|
if (type === 0)
|
|
result = await this._RequestOrientationPermission();
|
|
else if (type === 1)
|
|
result = await this._RequestMotionPermission();
|
|
this.PostToRuntime("permission-result", {
|
|
"type": type,
|
|
"result": result
|
|
})
|
|
}
|
|
async _RequestOrientationPermission() {
|
|
if (!self["DeviceOrientationEvent"] || !self["DeviceOrientationEvent"]["requestPermission"])
|
|
return true;
|
|
try {
|
|
const state = await self["DeviceOrientationEvent"]["requestPermission"]();
|
|
return state === "granted"
|
|
} catch (err) {
|
|
console.warn("[Touch] Failed to request orientation permission: ", err);
|
|
return false
|
|
}
|
|
}
|
|
async _RequestMotionPermission() {
|
|
if (!self["DeviceMotionEvent"] || !self["DeviceMotionEvent"]["requestPermission"])
|
|
return true;
|
|
try {
|
|
const state = await self["DeviceMotionEvent"]["requestPermission"]();
|
|
return state === "granted"
|
|
} catch (err) {
|
|
console.warn("[Touch] Failed to request motion permission: ", err);
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
;
|
|
self.RuntimeInterface.AddDOMHandlerClass(HANDLER_CLASS)
|
|
}
|
|
;'use strict';
|
|
{
|
|
const DOM_COMPONENT_ID = "mouse";
|
|
const HANDLER_CLASS = class MouseDOMHandler extends self.DOMHandler {
|
|
constructor(iRuntime) {
|
|
super(iRuntime, DOM_COMPONENT_ID);
|
|
this.AddRuntimeMessageHandler("cursor", e=>this._OnChangeCursorStyle(e))
|
|
}
|
|
_OnChangeCursorStyle(e) {
|
|
document.documentElement.style.cursor = e
|
|
}
|
|
}
|
|
;
|
|
self.RuntimeInterface.AddDOMHandlerClass(HANDLER_CLASS)
|
|
}
|
|
;'use strict';
|
|
{
|
|
const DOM_COMPONENT_ID = "browser";
|
|
const HANDLER_CLASS = class BrowserDOMHandler extends self.DOMHandler {
|
|
constructor(iRuntime) {
|
|
super(iRuntime, DOM_COMPONENT_ID);
|
|
this._exportType = "";
|
|
this.AddRuntimeMessageHandlers([["get-initial-state", e=>this._OnGetInitialState(e)], ["ready-for-sw-messages", ()=>this._OnReadyForSWMessages()], ["alert", e=>this._OnAlert(e)], ["close", ()=>this._OnClose()], ["set-focus", e=>this._OnSetFocus(e)], ["vibrate", e=>this._OnVibrate(e)], ["lock-orientation", e=>this._OnLockOrientation(e)], ["unlock-orientation", ()=>this._OnUnlockOrientation()], ["navigate", e=>this._OnNavigate(e)], ["request-fullscreen", e=>this._OnRequestFullscreen(e)], ["exit-fullscreen", ()=>this._OnExitFullscreen()], ["set-hash", e=>this._OnSetHash(e)]]);
|
|
window.addEventListener("online", ()=>this._OnOnlineStateChanged(true));
|
|
window.addEventListener("offline", ()=>this._OnOnlineStateChanged(false));
|
|
window.addEventListener("hashchange", ()=>this._OnHashChange());
|
|
document.addEventListener("backbutton", ()=>this._OnCordovaBackButton());
|
|
if (typeof Windows !== "undefined")
|
|
Windows["UI"]["Core"]["SystemNavigationManager"]["getForCurrentView"]().addEventListener("backrequested", e=>this._OnWin10BackRequested(e))
|
|
}
|
|
_OnGetInitialState(e) {
|
|
this._exportType = e["exportType"];
|
|
return {
|
|
"location": location.toString(),
|
|
"isOnline": !!navigator.onLine,
|
|
"referrer": document.referrer,
|
|
"title": document.title,
|
|
"isCookieEnabled": !!navigator.cookieEnabled,
|
|
"screenWidth": screen.width,
|
|
"screenHeight": screen.height,
|
|
"windowOuterWidth": window.outerWidth,
|
|
"windowOuterHeight": window.outerHeight,
|
|
"isScirraArcade": typeof window["is_scirra_arcade"] !== "undefined"
|
|
}
|
|
}
|
|
_OnReadyForSWMessages() {
|
|
if (!window["C3_RegisterSW"] || !window["OfflineClientInfo"])
|
|
return;
|
|
window["OfflineClientInfo"]["SetMessageCallback"](e=>this.PostToRuntime("sw-message", e["data"]))
|
|
}
|
|
_OnOnlineStateChanged(isOnline) {
|
|
this.PostToRuntime("online-state", {
|
|
"isOnline": isOnline
|
|
})
|
|
}
|
|
_OnCordovaBackButton() {
|
|
this.PostToRuntime("backbutton")
|
|
}
|
|
_OnWin10BackRequested(e) {
|
|
e["handled"] = true;
|
|
this.PostToRuntime("backbutton")
|
|
}
|
|
GetNWjsWindow() {
|
|
if (this._exportType === "nwjs")
|
|
return nw["Window"]["get"]();
|
|
else
|
|
return null
|
|
}
|
|
_OnAlert(e) {
|
|
alert(e["message"])
|
|
}
|
|
_OnClose() {
|
|
if (navigator["app"] && navigator["app"]["exitApp"])
|
|
navigator["app"]["exitApp"]();
|
|
else if (navigator["device"] && navigator["device"]["exitApp"])
|
|
navigator["device"]["exitApp"]();
|
|
else
|
|
window.close()
|
|
}
|
|
_OnSetFocus(e) {
|
|
const isFocus = e["isFocus"];
|
|
if (this._exportType === "nwjs") {
|
|
const win = this.GetNWjsWindow();
|
|
if (isFocus)
|
|
win["focus"]();
|
|
else
|
|
win["blur"]()
|
|
} else if (isFocus)
|
|
window.focus();
|
|
else
|
|
window.blur()
|
|
}
|
|
_OnVibrate(e) {
|
|
if (navigator["vibrate"])
|
|
navigator["vibrate"](e["pattern"])
|
|
}
|
|
_OnLockOrientation(e) {
|
|
const orientation = e["orientation"];
|
|
if (screen["orientation"] && screen["orientation"]["lock"])
|
|
screen["orientation"]["lock"](orientation).catch(err=>console.warn("[Construct 3] Failed to lock orientation: ", err));
|
|
else
|
|
try {
|
|
let result = false;
|
|
if (screen["lockOrientation"])
|
|
result = screen["lockOrientation"](orientation);
|
|
else if (screen["webkitLockOrientation"])
|
|
result = screen["webkitLockOrientation"](orientation);
|
|
else if (screen["mozLockOrientation"])
|
|
result = screen["mozLockOrientation"](orientation);
|
|
else if (screen["msLockOrientation"])
|
|
result = screen["msLockOrientation"](orientation);
|
|
if (!result)
|
|
console.warn("[Construct 3] Failed to lock orientation")
|
|
} catch (err) {
|
|
console.warn("[Construct 3] Failed to lock orientation: ", err)
|
|
}
|
|
}
|
|
_OnUnlockOrientation() {
|
|
try {
|
|
if (screen["orientation"] && screen["orientation"]["unlock"])
|
|
screen["orientation"]["unlock"]();
|
|
else if (screen["unlockOrientation"])
|
|
screen["unlockOrientation"]();
|
|
else if (screen["webkitUnlockOrientation"])
|
|
screen["webkitUnlockOrientation"]();
|
|
else if (screen["mozUnlockOrientation"])
|
|
screen["mozUnlockOrientation"]();
|
|
else if (screen["msUnlockOrientation"])
|
|
screen["msUnlockOrientation"]()
|
|
} catch (err) {}
|
|
}
|
|
_OnNavigate(e) {
|
|
const type = e["type"];
|
|
if (type === "back")
|
|
if (navigator["app"] && navigator["app"]["backHistory"])
|
|
navigator["app"]["backHistory"]();
|
|
else
|
|
window.back();
|
|
else if (type === "forward")
|
|
window.forward();
|
|
else if (type === "home")
|
|
window.home();
|
|
else if (type === "reload")
|
|
location.reload();
|
|
else if (type === "url") {
|
|
const url = e["url"];
|
|
const target = e["target"];
|
|
const exportType = e["exportType"];
|
|
if (exportType === "windows-uwp" && typeof Windows !== "undefined")
|
|
Windows["System"]["Launcher"]["launchUriAsync"](new Windows["Foundation"]["Uri"](url));
|
|
else if (self["cordova"] && self["cordova"]["InAppBrowser"])
|
|
self["cordova"]["InAppBrowser"]["open"](url, "_system");
|
|
else if (exportType === "preview")
|
|
window.open(url, "_blank");
|
|
else if (!this._isScirraArcade)
|
|
if (target === 2)
|
|
window.top.location = url;
|
|
else if (target === 1)
|
|
window.parent.location = url;
|
|
else
|
|
window.location = url
|
|
} else if (type === "new-window") {
|
|
const url = e["url"];
|
|
const tag = e["tag"];
|
|
const exportType = e["exportType"];
|
|
if (exportType === "windows-uwp" && typeof Windows !== "undefined")
|
|
Windows["System"]["Launcher"]["launchUriAsync"](new Windows["Foundation"]["Uri"](url));
|
|
else if (self["cordova"] && self["cordova"]["InAppBrowser"])
|
|
self["cordova"]["InAppBrowser"]["open"](url, "_system");
|
|
else
|
|
window.open(url, tag)
|
|
}
|
|
}
|
|
_OnRequestFullscreen(e) {
|
|
const opts = {
|
|
"navigationUI": "auto"
|
|
};
|
|
const navUI = e["navUI"];
|
|
if (navUI === 1)
|
|
opts["navigationUI"] = "hide";
|
|
else if (navUI === 2)
|
|
opts["navigationUI"] = "show";
|
|
const elem = document.documentElement;
|
|
if (elem["requestFullscreen"])
|
|
elem["requestFullscreen"](opts);
|
|
else if (elem["mozRequestFullScreen"])
|
|
elem["mozRequestFullScreen"](opts);
|
|
else if (elem["msRequestFullscreen"])
|
|
elem["msRequestFullscreen"](opts);
|
|
else if (elem["webkitRequestFullScreen"])
|
|
if (typeof Element["ALLOW_KEYBOARD_INPUT"] !== "undefined")
|
|
elem["webkitRequestFullScreen"](Element["ALLOW_KEYBOARD_INPUT"]);
|
|
else
|
|
elem["webkitRequestFullScreen"]()
|
|
}
|
|
_OnExitFullscreen() {
|
|
if (document["exitFullscreen"])
|
|
document["exitFullscreen"]();
|
|
else if (document["mozCancelFullScreen"])
|
|
document["mozCancelFullScreen"]();
|
|
else if (document["msExitFullscreen"])
|
|
document["msExitFullscreen"]();
|
|
else if (document["webkitCancelFullScreen"])
|
|
document["webkitCancelFullScreen"]()
|
|
}
|
|
_OnSetHash(e) {
|
|
location.hash = e["hash"]
|
|
}
|
|
_OnHashChange() {
|
|
this.PostToRuntime("hashchange", {
|
|
"location": location.toString()
|
|
})
|
|
}
|
|
}
|
|
;
|
|
self.RuntimeInterface.AddDOMHandlerClass(HANDLER_CLASS)
|
|
}
|
|
;'use strict';
|
|
{
|
|
const R_TO_D = 180 / Math.PI;
|
|
const DOM_COMPONENT_ID = "audio";
|
|
self.AudioDOMHandler = class AudioDOMHandler extends self.DOMHandler {
|
|
constructor(iRuntime) {
|
|
super(iRuntime, DOM_COMPONENT_ID);
|
|
this._audioContext = null;
|
|
this._destinationNode = null;
|
|
this._hasUnblocked = false;
|
|
this._hasAttachedUnblockEvents = false;
|
|
this._unblockFunc = ()=>this._UnblockAudioContext();
|
|
this._audioBuffers = [];
|
|
this._audioInstances = [];
|
|
this._lastAudioInstance = null;
|
|
this._lastPlayedTag = "";
|
|
this._lastTickCount = -1;
|
|
this._pendingTags = new Map;
|
|
this._masterVolume = 1;
|
|
this._isSilent = false;
|
|
this._timeScaleMode = 0;
|
|
this._timeScale = 1;
|
|
this._gameTime = 0;
|
|
this._panningModel = "HRTF";
|
|
this._distanceModel = "inverse";
|
|
this._refDistance = 600;
|
|
this._maxDistance = 1E4;
|
|
this._rolloffFactor = 1;
|
|
this._playMusicAsSound = false;
|
|
this._hasAnySoftwareDecodedMusic = false;
|
|
this._supportsWebMOpus = this._iRuntime.IsAudioFormatSupported("audio/webm; codecs=opus");
|
|
this._effects = new Map;
|
|
this._analysers = new Set;
|
|
this._isPendingPostFxState = false;
|
|
this._microphoneTag = "";
|
|
this._microphoneSource = null;
|
|
self["C3Audio_OnMicrophoneStream"] = (localMediaStream,tag)=>this._OnMicrophoneStream(localMediaStream, tag);
|
|
this._destMediaStreamNode = null;
|
|
self["C3Audio_GetOutputStream"] = ()=>this._OnGetOutputStream();
|
|
self["C3Audio_DOMInterface"] = this;
|
|
this.AddRuntimeMessageHandlers([["create-audio-context", e=>this._CreateAudioContext(e)], ["play", e=>this._Play(e)], ["stop", e=>this._Stop(e)], ["stop-all", ()=>this._StopAll()], ["set-paused", e=>this._SetPaused(e)], ["set-volume", e=>this._SetVolume(e)], ["fade-volume", e=>this._FadeVolume(e)], ["set-master-volume", e=>this._SetMasterVolume(e)], ["set-muted", e=>this._SetMuted(e)], ["set-silent", e=>this._SetSilent(e)], ["set-looping", e=>this._SetLooping(e)], ["set-playback-rate", e=>this._SetPlaybackRate(e)], ["seek", e=>this._Seek(e)], ["preload", e=>this._Preload(e)], ["unload", e=>this._Unload(e)], ["unload-all", ()=>this._UnloadAll()], ["set-suspended", e=>this._SetSuspended(e)], ["add-effect", e=>this._AddEffect(e)], ["set-effect-param", e=>this._SetEffectParam(e)], ["remove-effects", e=>this._RemoveEffects(e)], ["tick", e=>this._OnTick(e)], ["load-state", e=>this._OnLoadState(e)]])
|
|
}
|
|
async _CreateAudioContext(e) {
|
|
if (e["isiOSCordova"])
|
|
this._playMusicAsSound = true;
|
|
this._timeScaleMode = e["timeScaleMode"];
|
|
this._panningModel = ["equalpower", "HRTF", "soundfield"][e["panningModel"]];
|
|
this._distanceModel = ["linear", "inverse", "exponential"][e["distanceModel"]];
|
|
this._refDistance = e["refDistance"];
|
|
this._maxDistance = e["maxDistance"];
|
|
this._rolloffFactor = e["rolloffFactor"];
|
|
const opts = {
|
|
"latencyHint": e["latencyHint"]
|
|
};
|
|
if (typeof AudioContext !== "undefined")
|
|
this._audioContext = new AudioContext(opts);
|
|
else if (typeof webkitAudioContext !== "undefined")
|
|
this._audioContext = new webkitAudioContext(opts);
|
|
else
|
|
throw new Error("Web Audio API not supported");
|
|
this._AttachUnblockEvents();
|
|
this._audioContext.onstatechange = ()=>{
|
|
if (this._audioContext.state !== "running")
|
|
this._AttachUnblockEvents()
|
|
}
|
|
;
|
|
this._destinationNode = this._audioContext["createGain"]();
|
|
this._destinationNode["connect"](this._audioContext["destination"]);
|
|
const listenerPos = e["listenerPos"];
|
|
this._audioContext["listener"]["setPosition"](listenerPos[0], listenerPos[1], listenerPos[2]);
|
|
this._audioContext["listener"]["setOrientation"](0, 0, 1, 0, -1, 0);
|
|
self["C3_GetAudioContextCurrentTime"] = ()=>this.GetAudioCurrentTime();
|
|
try {
|
|
await Promise.all(e["preloadList"].map(o=>this._GetAudioBuffer(o["originalUrl"], o["url"], o["type"], false)))
|
|
} catch (err) {
|
|
console.error("[Construct 3] Preloading sounds failed: ", err)
|
|
}
|
|
return {
|
|
"sampleRate": this._audioContext["sampleRate"]
|
|
}
|
|
}
|
|
_AttachUnblockEvents() {
|
|
if (this._hasAttachedUnblockEvents)
|
|
return;
|
|
this._hasUnblocked = false;
|
|
window.addEventListener("pointerup", this._unblockFunc, true);
|
|
window.addEventListener("touchend", this._unblockFunc, true);
|
|
window.addEventListener("click", this._unblockFunc, true);
|
|
window.addEventListener("keydown", this._unblockFunc, true);
|
|
this._hasAttachedUnblockEvents = true
|
|
}
|
|
_DetachUnblockEvents() {
|
|
if (!this._hasAttachedUnblockEvents)
|
|
return;
|
|
this._hasUnblocked = true;
|
|
window.removeEventListener("pointerup", this._unblockFunc, true);
|
|
window.removeEventListener("touchend", this._unblockFunc, true);
|
|
window.removeEventListener("click", this._unblockFunc, true);
|
|
window.removeEventListener("keydown", this._unblockFunc, true);
|
|
this._hasAttachedUnblockEvents = false
|
|
}
|
|
_UnblockAudioContext() {
|
|
if (this._hasUnblocked)
|
|
return;
|
|
const audioContext = this._audioContext;
|
|
if (audioContext["state"] === "suspended" && audioContext["resume"])
|
|
audioContext["resume"]();
|
|
const buffer = audioContext["createBuffer"](1, 220, 22050);
|
|
const source = audioContext["createBufferSource"]();
|
|
source["buffer"] = buffer;
|
|
source["connect"](audioContext["destination"]);
|
|
source["start"](0);
|
|
if (audioContext["state"] === "running")
|
|
this._DetachUnblockEvents()
|
|
}
|
|
GetAudioContext() {
|
|
return this._audioContext
|
|
}
|
|
GetAudioCurrentTime() {
|
|
return this._audioContext["currentTime"]
|
|
}
|
|
GetDestinationNode() {
|
|
return this._destinationNode
|
|
}
|
|
GetDestinationForTag(tag) {
|
|
const fxChain = this._effects.get(tag.toLowerCase());
|
|
if (fxChain)
|
|
return fxChain[0].GetInputNode();
|
|
else
|
|
return this.GetDestinationNode()
|
|
}
|
|
AddEffectForTag(tag, effect) {
|
|
tag = tag.toLowerCase();
|
|
let fxChain = this._effects.get(tag);
|
|
if (!fxChain) {
|
|
fxChain = [];
|
|
this._effects.set(tag, fxChain)
|
|
}
|
|
effect._SetIndex(fxChain.length);
|
|
effect._SetTag(tag);
|
|
fxChain.push(effect);
|
|
this._ReconnectEffects(tag)
|
|
}
|
|
_ReconnectEffects(tag) {
|
|
let destNode = this.GetDestinationNode();
|
|
const fxChain = this._effects.get(tag);
|
|
if (fxChain && fxChain.length) {
|
|
destNode = fxChain[0].GetInputNode();
|
|
for (let i = 0, len = fxChain.length; i < len; ++i) {
|
|
const n = fxChain[i];
|
|
if (i + 1 === len)
|
|
n.ConnectTo(this.GetDestinationNode());
|
|
else
|
|
n.ConnectTo(fxChain[i + 1].GetInputNode())
|
|
}
|
|
}
|
|
for (const ai of this.audioInstancesByTag(tag))
|
|
ai.Reconnect(destNode);
|
|
if (this._microphoneSource && this._microphoneTag === tag) {
|
|
this._microphoneSource["disconnect"]();
|
|
this._microphoneSource["connect"](destNode)
|
|
}
|
|
}
|
|
GetMasterVolume() {
|
|
return this._masterVolume
|
|
}
|
|
IsSilent() {
|
|
return this._isSilent
|
|
}
|
|
GetTimeScaleMode() {
|
|
return this._timeScaleMode
|
|
}
|
|
GetTimeScale() {
|
|
return this._timeScale
|
|
}
|
|
GetGameTime() {
|
|
return this._gameTime
|
|
}
|
|
IsPlayMusicAsSound() {
|
|
return this._playMusicAsSound
|
|
}
|
|
SupportsWebMOpus() {
|
|
return this._supportsWebMOpus
|
|
}
|
|
_SetHasAnySoftwareDecodedMusic() {
|
|
this._hasAnySoftwareDecodedMusic = true
|
|
}
|
|
GetPanningModel() {
|
|
return this._panningModel
|
|
}
|
|
GetDistanceModel() {
|
|
return this._distanceModel
|
|
}
|
|
GetReferenceDistance() {
|
|
return this._refDistance
|
|
}
|
|
GetMaxDistance() {
|
|
return this._maxDistance
|
|
}
|
|
GetRolloffFactor() {
|
|
return this._rolloffFactor
|
|
}
|
|
DecodeAudioData(audioData, needsSoftwareDecode) {
|
|
if (needsSoftwareDecode)
|
|
return this._iRuntime._WasmDecodeWebMOpus(audioData).then(rawAudio=>{
|
|
const audioBuffer = this._audioContext["createBuffer"](1, rawAudio.length, 48E3);
|
|
const channelBuffer = audioBuffer["getChannelData"](0);
|
|
channelBuffer.set(rawAudio);
|
|
return audioBuffer
|
|
}
|
|
);
|
|
else
|
|
return new Promise((resolve,reject)=>{
|
|
this._audioContext["decodeAudioData"](audioData, resolve, reject)
|
|
}
|
|
)
|
|
}
|
|
TryPlayMedia(mediaElem) {
|
|
this._iRuntime.TryPlayMedia(mediaElem)
|
|
}
|
|
RemovePendingPlay(mediaElem) {
|
|
this._iRuntime.RemovePendingPlay(mediaElem)
|
|
}
|
|
ReleaseInstancesForBuffer(buffer) {
|
|
let j = 0;
|
|
for (let i = 0, len = this._audioInstances.length; i < len; ++i) {
|
|
const a = this._audioInstances[i];
|
|
this._audioInstances[j] = a;
|
|
if (a.GetBuffer() === buffer)
|
|
a.Release();
|
|
else
|
|
++j
|
|
}
|
|
this._audioInstances.length = j
|
|
}
|
|
ReleaseAllMusicBuffers() {
|
|
let j = 0;
|
|
for (let i = 0, len = this._audioBuffers.length; i < len; ++i) {
|
|
const b = this._audioBuffers[i];
|
|
this._audioBuffers[j] = b;
|
|
if (b.IsMusic())
|
|
b.Release();
|
|
else
|
|
++j
|
|
}
|
|
this._audioBuffers.length = j
|
|
}
|
|
*audioInstancesByTag(tag) {
|
|
if (tag)
|
|
for (const ai of this._audioInstances) {
|
|
if (self.AudioDOMHandler.EqualsNoCase(ai.GetTag(), tag))
|
|
yield ai
|
|
}
|
|
else if (this._lastAudioInstance && !this._lastAudioInstance.HasEnded())
|
|
yield this._lastAudioInstance
|
|
}
|
|
async _GetAudioBuffer(originalUrl, url, type, isMusic, dontCreate) {
|
|
for (const ab of this._audioBuffers)
|
|
if (ab.GetUrl() === url) {
|
|
await ab.Load();
|
|
return ab
|
|
}
|
|
if (dontCreate)
|
|
return null;
|
|
if (isMusic && (this._playMusicAsSound || this._hasAnySoftwareDecodedMusic))
|
|
this.ReleaseAllMusicBuffers();
|
|
const ret = self.C3AudioBuffer.Create(this, originalUrl, url, type, isMusic);
|
|
this._audioBuffers.push(ret);
|
|
await ret.Load();
|
|
return ret
|
|
}
|
|
async _GetAudioInstance(originalUrl, url, type, tag, isMusic) {
|
|
for (const ai of this._audioInstances)
|
|
if (ai.GetUrl() === url && (ai.CanBeRecycled() || isMusic)) {
|
|
ai.SetTag(tag);
|
|
return ai
|
|
}
|
|
const buffer = await this._GetAudioBuffer(originalUrl, url, type, isMusic);
|
|
const ret = buffer.CreateInstance(tag);
|
|
this._audioInstances.push(ret);
|
|
return ret
|
|
}
|
|
_AddPendingTag(tag) {
|
|
let info = this._pendingTags.get(tag);
|
|
if (!info) {
|
|
let resolve = null;
|
|
const promise = new Promise(r=>resolve = r);
|
|
info = {
|
|
pendingCount: 0,
|
|
promise,
|
|
resolve
|
|
};
|
|
this._pendingTags.set(tag, info)
|
|
}
|
|
info.pendingCount++
|
|
}
|
|
_RemovePendingTag(tag) {
|
|
const info = this._pendingTags.get(tag);
|
|
if (!info)
|
|
throw new Error("expected pending tag");
|
|
info.pendingCount--;
|
|
if (info.pendingCount === 0) {
|
|
info.resolve();
|
|
this._pendingTags.delete(tag)
|
|
}
|
|
}
|
|
TagReady(tag) {
|
|
if (!tag)
|
|
tag = this._lastPlayedTag;
|
|
const info = this._pendingTags.get(tag);
|
|
if (info)
|
|
return info.promise;
|
|
else
|
|
return Promise.resolve()
|
|
}
|
|
_MaybeStartTicking() {
|
|
if (this._analysers.size > 0) {
|
|
this._StartTicking();
|
|
return
|
|
}
|
|
for (const ai of this._audioInstances)
|
|
if (ai.IsActive()) {
|
|
this._StartTicking();
|
|
return
|
|
}
|
|
}
|
|
Tick() {
|
|
for (const a of this._analysers)
|
|
a.Tick();
|
|
const currentTime = this.GetAudioCurrentTime();
|
|
for (const ai of this._audioInstances)
|
|
ai.Tick(currentTime);
|
|
const instStates = this._audioInstances.filter(a=>a.IsActive()).map(a=>a.GetState());
|
|
this.PostToRuntime("state", {
|
|
"tickCount": this._lastTickCount,
|
|
"audioInstances": instStates,
|
|
"analysers": [...this._analysers].map(a=>a.GetData())
|
|
});
|
|
if (instStates.length === 0 && this._analysers.size === 0)
|
|
this._StopTicking()
|
|
}
|
|
PostTrigger(type, tag, aiid) {
|
|
this.PostToRuntime("trigger", {
|
|
"type": type,
|
|
"tag": tag,
|
|
"aiid": aiid
|
|
})
|
|
}
|
|
async _Play(e) {
|
|
const originalUrl = e["originalUrl"];
|
|
const url = e["url"];
|
|
const type = e["type"];
|
|
const isMusic = e["isMusic"];
|
|
const tag = e["tag"];
|
|
const isLooping = e["isLooping"];
|
|
const volume = e["vol"];
|
|
const position = e["pos"];
|
|
const panning = e["panning"];
|
|
let startTime = e["off"];
|
|
if (startTime > 0 && !e["trueClock"])
|
|
if (this._audioContext["getOutputTimestamp"]) {
|
|
const outputTimestamp = this._audioContext["getOutputTimestamp"]();
|
|
startTime = startTime - outputTimestamp["performanceTime"] / 1E3 + outputTimestamp["contextTime"]
|
|
} else
|
|
startTime = startTime - performance.now() / 1E3 + this._audioContext["currentTime"];
|
|
this._lastPlayedTag = tag;
|
|
this._AddPendingTag(tag);
|
|
try {
|
|
this._lastAudioInstance = await this._GetAudioInstance(originalUrl, url, type, tag, isMusic);
|
|
if (panning) {
|
|
this._lastAudioInstance.SetPannerEnabled(true);
|
|
this._lastAudioInstance.SetPan(panning["x"], panning["y"], panning["angle"], panning["innerAngle"], panning["outerAngle"], panning["outerGain"]);
|
|
if (panning.hasOwnProperty("uid"))
|
|
this._lastAudioInstance.SetUID(panning["uid"])
|
|
} else
|
|
this._lastAudioInstance.SetPannerEnabled(false);
|
|
this._lastAudioInstance.Play(isLooping, volume, position, startTime)
|
|
} catch (err) {
|
|
console.error("[Construct 3] Audio: error starting playback: ", err);
|
|
return
|
|
} finally {
|
|
this._RemovePendingTag(tag)
|
|
}
|
|
this._StartTicking()
|
|
}
|
|
_Stop(e) {
|
|
const tag = e["tag"];
|
|
for (const ai of this.audioInstancesByTag(tag))
|
|
ai.Stop()
|
|
}
|
|
_StopAll() {
|
|
for (const ai of this._audioInstances)
|
|
ai.Stop()
|
|
}
|
|
_SetPaused(e) {
|
|
const tag = e["tag"];
|
|
const paused = e["paused"];
|
|
for (const ai of this.audioInstancesByTag(tag))
|
|
if (paused)
|
|
ai.Pause();
|
|
else
|
|
ai.Resume();
|
|
this._MaybeStartTicking()
|
|
}
|
|
_SetVolume(e) {
|
|
const tag = e["tag"];
|
|
const vol = e["vol"];
|
|
for (const ai of this.audioInstancesByTag(tag))
|
|
ai.SetVolume(vol)
|
|
}
|
|
async _FadeVolume(e) {
|
|
const tag = e["tag"];
|
|
const vol = e["vol"];
|
|
const duration = e["duration"];
|
|
const stopOnEnd = e["stopOnEnd"];
|
|
await this.TagReady(tag);
|
|
for (const ai of this.audioInstancesByTag(tag))
|
|
ai.FadeVolume(vol, duration, stopOnEnd);
|
|
this._MaybeStartTicking()
|
|
}
|
|
_SetMasterVolume(e) {
|
|
this._masterVolume = e["vol"];
|
|
for (const ai of this._audioInstances)
|
|
ai._UpdateVolume()
|
|
}
|
|
_SetMuted(e) {
|
|
const tag = e["tag"];
|
|
const isMuted = e["isMuted"];
|
|
for (const ai of this.audioInstancesByTag(tag))
|
|
ai.SetMuted(isMuted)
|
|
}
|
|
_SetSilent(e) {
|
|
this._isSilent = e["isSilent"];
|
|
this._iRuntime.SetSilent(this._isSilent);
|
|
for (const ai of this._audioInstances)
|
|
ai._UpdateMuted()
|
|
}
|
|
_SetLooping(e) {
|
|
const tag = e["tag"];
|
|
const isLooping = e["isLooping"];
|
|
for (const ai of this.audioInstancesByTag(tag))
|
|
ai.SetLooping(isLooping)
|
|
}
|
|
async _SetPlaybackRate(e) {
|
|
const tag = e["tag"];
|
|
const rate = e["rate"];
|
|
await this.TagReady(tag);
|
|
for (const ai of this.audioInstancesByTag(tag))
|
|
ai.SetPlaybackRate(rate)
|
|
}
|
|
async _Seek(e) {
|
|
const tag = e["tag"];
|
|
const pos = e["pos"];
|
|
await this.TagReady(tag);
|
|
for (const ai of this.audioInstancesByTag(tag))
|
|
ai.Seek(pos)
|
|
}
|
|
async _Preload(e) {
|
|
const originalUrl = e["originalUrl"];
|
|
const url = e["url"];
|
|
const type = e["type"];
|
|
const isMusic = e["isMusic"];
|
|
try {
|
|
await this._GetAudioInstance(originalUrl, url, type, "", isMusic)
|
|
} catch (err) {
|
|
console.error("[Construct 3] Audio: error preloading: ", err)
|
|
}
|
|
}
|
|
async _Unload(e) {
|
|
const url = e["url"];
|
|
const type = e["type"];
|
|
const isMusic = e["isMusic"];
|
|
const buffer = await this._GetAudioBuffer("", url, type, isMusic, true);
|
|
if (!buffer)
|
|
return;
|
|
buffer.Release();
|
|
const i = this._audioBuffers.indexOf(buffer);
|
|
if (i !== -1)
|
|
this._audioBuffers.splice(i, 1)
|
|
}
|
|
_UnloadAll() {
|
|
for (const buffer of this._audioBuffers)
|
|
buffer.Release();
|
|
this._audioBuffers.length = 0
|
|
}
|
|
_SetSuspended(e) {
|
|
const isSuspended = e["isSuspended"];
|
|
if (!isSuspended && this._audioContext["resume"])
|
|
this._audioContext["resume"]();
|
|
for (const ai of this._audioInstances)
|
|
ai.SetSuspended(isSuspended);
|
|
if (isSuspended && this._audioContext["suspend"])
|
|
this._audioContext["suspend"]()
|
|
}
|
|
_OnTick(e) {
|
|
this._timeScale = e["timeScale"];
|
|
this._gameTime = e["gameTime"];
|
|
this._lastTickCount = e["tickCount"];
|
|
if (this._timeScaleMode !== 0)
|
|
for (const ai of this._audioInstances)
|
|
ai._UpdatePlaybackRate();
|
|
const listenerPos = e["listenerPos"];
|
|
if (listenerPos)
|
|
this._audioContext["listener"]["setPosition"](listenerPos[0], listenerPos[1], listenerPos[2]);
|
|
for (const instPan of e["instPans"]) {
|
|
const uid = instPan["uid"];
|
|
for (const ai of this._audioInstances)
|
|
if (ai.GetUID() === uid)
|
|
ai.SetPanXYA(instPan["x"], instPan["y"], instPan["angle"])
|
|
}
|
|
}
|
|
async _AddEffect(e) {
|
|
const type = e["type"];
|
|
const tag = e["tag"];
|
|
const params = e["params"];
|
|
let effect;
|
|
if (type === "filter")
|
|
effect = new self.C3AudioFilterFX(this,...params);
|
|
else if (type === "delay")
|
|
effect = new self.C3AudioDelayFX(this,...params);
|
|
else if (type === "convolution") {
|
|
let buffer = null;
|
|
try {
|
|
buffer = await this._GetAudioBuffer(e["bufferOriginalUrl"], e["bufferUrl"], e["bufferType"], false)
|
|
} catch (err) {
|
|
console.log("[Construct 3] Audio: error loading convolution: ", err);
|
|
return
|
|
}
|
|
effect = new self.C3AudioConvolveFX(this,buffer.GetAudioBuffer(),...params);
|
|
effect._SetBufferInfo(e["bufferOriginalUrl"], e["bufferUrl"], e["bufferType"])
|
|
} else if (type === "flanger")
|
|
effect = new self.C3AudioFlangerFX(this,...params);
|
|
else if (type === "phaser")
|
|
effect = new self.C3AudioPhaserFX(this,...params);
|
|
else if (type === "gain")
|
|
effect = new self.C3AudioGainFX(this,...params);
|
|
else if (type === "tremolo")
|
|
effect = new self.C3AudioTremoloFX(this,...params);
|
|
else if (type === "ringmod")
|
|
effect = new self.C3AudioRingModFX(this,...params);
|
|
else if (type === "distortion")
|
|
effect = new self.C3AudioDistortionFX(this,...params);
|
|
else if (type === "compressor")
|
|
effect = new self.C3AudioCompressorFX(this,...params);
|
|
else if (type === "analyser")
|
|
effect = new self.C3AudioAnalyserFX(this,...params);
|
|
else
|
|
throw new Error("invalid effect type");
|
|
this.AddEffectForTag(tag, effect);
|
|
this._PostUpdatedFxState()
|
|
}
|
|
_SetEffectParam(e) {
|
|
const tag = e["tag"];
|
|
const index = e["index"];
|
|
const param = e["param"];
|
|
const value = e["value"];
|
|
const ramp = e["ramp"];
|
|
const time = e["time"];
|
|
const fxChain = this._effects.get(tag);
|
|
if (!fxChain || index < 0 || index >= fxChain.length)
|
|
return;
|
|
fxChain[index].SetParam(param, value, ramp, time);
|
|
this._PostUpdatedFxState()
|
|
}
|
|
_RemoveEffects(e) {
|
|
const tag = e["tag"].toLowerCase();
|
|
const fxChain = this._effects.get(tag);
|
|
if (!fxChain || !fxChain.length)
|
|
return;
|
|
for (const effect of fxChain)
|
|
effect.Release();
|
|
this._effects.delete(tag);
|
|
this._ReconnectEffects(tag)
|
|
}
|
|
_AddAnalyser(analyser) {
|
|
this._analysers.add(analyser);
|
|
this._MaybeStartTicking()
|
|
}
|
|
_RemoveAnalyser(analyser) {
|
|
this._analysers.delete(analyser)
|
|
}
|
|
_PostUpdatedFxState() {
|
|
if (this._isPendingPostFxState)
|
|
return;
|
|
this._isPendingPostFxState = true;
|
|
Promise.resolve().then(()=>this._DoPostUpdatedFxState())
|
|
}
|
|
_DoPostUpdatedFxState() {
|
|
const fxstate = {};
|
|
for (const [tag,fxChain] of this._effects)
|
|
fxstate[tag] = fxChain.map(e=>e.GetState());
|
|
this.PostToRuntime("fxstate", {
|
|
"fxstate": fxstate
|
|
});
|
|
this._isPendingPostFxState = false
|
|
}
|
|
async _OnLoadState(e) {
|
|
const saveLoadMode = e["saveLoadMode"];
|
|
if (saveLoadMode !== 3)
|
|
for (const ai of this._audioInstances) {
|
|
if (ai.IsMusic() && saveLoadMode === 1)
|
|
continue;
|
|
if (!ai.IsMusic() && saveLoadMode === 2)
|
|
continue;
|
|
ai.Stop()
|
|
}
|
|
for (const fxChain of this._effects.values())
|
|
for (const effect of fxChain)
|
|
effect.Release();
|
|
this._effects.clear();
|
|
this._timeScale = e["timeScale"];
|
|
this._gameTime = e["gameTime"];
|
|
const listenerPos = e["listenerPos"];
|
|
this._audioContext["listener"]["setPosition"](listenerPos[0], listenerPos[1], listenerPos[2]);
|
|
this._isSilent = e["isSilent"];
|
|
this._iRuntime.SetSilent(this._isSilent);
|
|
this._masterVolume = e["masterVolume"];
|
|
const promises = [];
|
|
for (const fxChainData of Object.values(e["effects"]))
|
|
promises.push(Promise.all(fxChainData.map(d=>this._AddEffect(d))));
|
|
await Promise.all(promises);
|
|
await Promise.all(e["playing"].map(d=>this._LoadAudioInstance(d, saveLoadMode)));
|
|
this._MaybeStartTicking()
|
|
}
|
|
async _LoadAudioInstance(d, saveLoadMode) {
|
|
if (saveLoadMode === 3)
|
|
return;
|
|
const originalUrl = d["bufferOriginalUrl"];
|
|
const url = d["bufferUrl"];
|
|
const type = d["bufferType"];
|
|
const isMusic = d["isMusic"];
|
|
const tag = d["tag"];
|
|
const isLooping = d["isLooping"];
|
|
const volume = d["volume"];
|
|
const position = d["playbackTime"];
|
|
if (isMusic && saveLoadMode === 1)
|
|
return;
|
|
if (!isMusic && saveLoadMode === 2)
|
|
return;
|
|
let ai = null;
|
|
try {
|
|
ai = await this._GetAudioInstance(originalUrl, url, type, tag, isMusic)
|
|
} catch (err) {
|
|
console.error("[Construct 3] Audio: error loading audio state: ", err);
|
|
return
|
|
}
|
|
ai.LoadPanState(d["pan"]);
|
|
ai.Play(isLooping, volume, position, 0);
|
|
if (!d["isPlaying"])
|
|
ai.Pause();
|
|
ai._LoadAdditionalState(d)
|
|
}
|
|
_OnMicrophoneStream(localMediaStream, tag) {
|
|
if (this._microphoneSource)
|
|
this._microphoneSource["disconnect"]();
|
|
this._microphoneTag = tag.toLowerCase();
|
|
this._microphoneSource = this._audioContext["createMediaStreamSource"](localMediaStream);
|
|
this._microphoneSource["connect"](this.GetDestinationForTag(this._microphoneTag))
|
|
}
|
|
_OnGetOutputStream() {
|
|
if (!this._destMediaStreamNode) {
|
|
this._destMediaStreamNode = this._audioContext["createMediaStreamDestination"]();
|
|
this._destinationNode["connect"](this._destMediaStreamNode)
|
|
}
|
|
return this._destMediaStreamNode["stream"]
|
|
}
|
|
static EqualsNoCase(a, b) {
|
|
if (a.length !== b.length)
|
|
return false;
|
|
if (a === b)
|
|
return true;
|
|
return a.toLowerCase() === b.toLowerCase()
|
|
}
|
|
static ToDegrees(x) {
|
|
return x * R_TO_D
|
|
}
|
|
static DbToLinearNoCap(x) {
|
|
return Math.pow(10, x / 20)
|
|
}
|
|
static DbToLinear(x) {
|
|
return Math.max(Math.min(self.AudioDOMHandler.DbToLinearNoCap(x), 1), 0)
|
|
}
|
|
static LinearToDbNoCap(x) {
|
|
return Math.log(x) / Math.log(10) * 20
|
|
}
|
|
static LinearToDb(x) {
|
|
return self.AudioDOMHandler.LinearToDbNoCap(Math.max(Math.min(x, 1), 0))
|
|
}
|
|
static e4(x, k) {
|
|
return 1 - Math.exp(-k * x)
|
|
}
|
|
}
|
|
;
|
|
self.RuntimeInterface.AddDOMHandlerClass(self.AudioDOMHandler)
|
|
}
|
|
;'use strict';
|
|
{
|
|
self.C3AudioBuffer = class C3AudioBuffer {
|
|
constructor(audioDomHandler, originalUrl, url, type, isMusic) {
|
|
this._audioDomHandler = audioDomHandler;
|
|
this._originalUrl = originalUrl;
|
|
this._url = url;
|
|
this._type = type;
|
|
this._isMusic = isMusic;
|
|
this._api = "";
|
|
this._loadState = "not-loaded";
|
|
this._loadPromise = null
|
|
}
|
|
Release() {
|
|
this._loadState = "not-loaded";
|
|
this._audioDomHandler = null;
|
|
this._loadPromise = null
|
|
}
|
|
static Create(audioDomHandler, originalUrl, url, type, isMusic) {
|
|
const needsSoftwareDecode = type === "audio/webm; codecs=opus" && !audioDomHandler.SupportsWebMOpus();
|
|
if (isMusic && needsSoftwareDecode)
|
|
audioDomHandler._SetHasAnySoftwareDecodedMusic();
|
|
if (!isMusic || audioDomHandler.IsPlayMusicAsSound() || needsSoftwareDecode)
|
|
return new self.C3WebAudioBuffer(audioDomHandler,originalUrl,url,type,isMusic,needsSoftwareDecode);
|
|
else
|
|
return new self.C3Html5AudioBuffer(audioDomHandler,originalUrl,url,type,isMusic)
|
|
}
|
|
CreateInstance(tag) {
|
|
if (this._api === "html5")
|
|
return new self.C3Html5AudioInstance(this._audioDomHandler,this,tag);
|
|
else
|
|
return new self.C3WebAudioInstance(this._audioDomHandler,this,tag)
|
|
}
|
|
_Load() {}
|
|
Load() {
|
|
if (!this._loadPromise)
|
|
this._loadPromise = this._Load();
|
|
return this._loadPromise
|
|
}
|
|
IsLoaded() {}
|
|
IsLoadedAndDecoded() {}
|
|
HasFailedToLoad() {
|
|
return this._loadState === "failed"
|
|
}
|
|
GetAudioContext() {
|
|
return this._audioDomHandler.GetAudioContext()
|
|
}
|
|
GetApi() {
|
|
return this._api
|
|
}
|
|
GetOriginalUrl() {
|
|
return this._originalUrl
|
|
}
|
|
GetUrl() {
|
|
return this._url
|
|
}
|
|
GetContentType() {
|
|
return this._type
|
|
}
|
|
IsMusic() {
|
|
return this._isMusic
|
|
}
|
|
GetDuration() {}
|
|
}
|
|
}
|
|
;'use strict';
|
|
{
|
|
self.C3Html5AudioBuffer = class C3Html5AudioBuffer extends self.C3AudioBuffer {
|
|
constructor(audioDomHandler, originalUrl, url, type, isMusic) {
|
|
super(audioDomHandler, originalUrl, url, type, isMusic);
|
|
this._api = "html5";
|
|
this._audioElem = new Audio;
|
|
this._audioElem.crossOrigin = "anonymous";
|
|
this._audioElem.autoplay = false;
|
|
this._audioElem.preload = "auto";
|
|
this._loadResolve = null;
|
|
this._loadReject = null;
|
|
this._reachedCanPlayThrough = false;
|
|
this._audioElem.addEventListener("canplaythrough", ()=>this._reachedCanPlayThrough = true);
|
|
this._outNode = this.GetAudioContext()["createGain"]();
|
|
this._mediaSourceNode = null;
|
|
this._audioElem.addEventListener("canplay", ()=>{
|
|
if (this._loadResolve) {
|
|
this._loadState = "loaded";
|
|
this._loadResolve();
|
|
this._loadResolve = null;
|
|
this._loadReject = null
|
|
}
|
|
if (this._mediaSourceNode || !this._audioElem)
|
|
return;
|
|
this._mediaSourceNode = this.GetAudioContext()["createMediaElementSource"](this._audioElem);
|
|
this._mediaSourceNode["connect"](this._outNode)
|
|
}
|
|
);
|
|
this.onended = null;
|
|
this._audioElem.addEventListener("ended", ()=>{
|
|
if (this.onended)
|
|
this.onended()
|
|
}
|
|
);
|
|
this._audioElem.addEventListener("error", e=>this._OnError(e))
|
|
}
|
|
Release() {
|
|
this._audioDomHandler.ReleaseInstancesForBuffer(this);
|
|
this._outNode["disconnect"]();
|
|
this._outNode = null;
|
|
this._mediaSourceNode["disconnect"]();
|
|
this._mediaSourceNode = null;
|
|
if (this._audioElem && !this._audioElem.paused)
|
|
this._audioElem.pause();
|
|
this.onended = null;
|
|
this._audioElem = null;
|
|
super.Release()
|
|
}
|
|
_Load() {
|
|
this._loadState = "loading";
|
|
return new Promise((resolve,reject)=>{
|
|
this._loadResolve = resolve;
|
|
this._loadReject = reject;
|
|
this._audioElem.src = this._url
|
|
}
|
|
)
|
|
}
|
|
_OnError(e) {
|
|
console.error(`[Construct 3] Audio '${this._url}' error: `, e);
|
|
if (this._loadReject) {
|
|
this._loadState = "failed";
|
|
this._loadReject(e);
|
|
this._loadResolve = null;
|
|
this._loadReject = null
|
|
}
|
|
}
|
|
IsLoaded() {
|
|
const ret = this._audioElem["readyState"] >= 4;
|
|
if (ret)
|
|
this._reachedCanPlayThrough = true;
|
|
return ret || this._reachedCanPlayThrough
|
|
}
|
|
IsLoadedAndDecoded() {
|
|
return this.IsLoaded()
|
|
}
|
|
GetAudioElement() {
|
|
return this._audioElem
|
|
}
|
|
GetOutputNode() {
|
|
return this._outNode
|
|
}
|
|
GetDuration() {
|
|
return this._audioElem["duration"]
|
|
}
|
|
}
|
|
}
|
|
;'use strict';
|
|
{
|
|
self.C3WebAudioBuffer = class C3WebAudioBuffer extends self.C3AudioBuffer {
|
|
constructor(audioDomHandler, originalUrl, url, type, isMusic, needsSoftwareDecode) {
|
|
super(audioDomHandler, originalUrl, url, type, isMusic);
|
|
this._api = "webaudio";
|
|
this._audioData = null;
|
|
this._audioBuffer = null;
|
|
this._needsSoftwareDecode = !!needsSoftwareDecode
|
|
}
|
|
Release() {
|
|
this._audioDomHandler.ReleaseInstancesForBuffer(this);
|
|
this._audioData = null;
|
|
this._audioBuffer = null;
|
|
super.Release()
|
|
}
|
|
async _Fetch() {
|
|
if (this._audioData)
|
|
return this._audioData;
|
|
const iRuntime = this._audioDomHandler.GetRuntimeInterface();
|
|
if (iRuntime.GetExportType() === "cordova" && iRuntime.IsRelativeURL(this._url) && location.protocol === "file:")
|
|
this._audioData = await iRuntime.CordovaFetchLocalFileAsArrayBuffer(this._url);
|
|
else {
|
|
const response = await fetch(this._url);
|
|
if (!response.ok)
|
|
throw new Error(`error fetching audio data: ${response.status} ${response.statusText}`);
|
|
this._audioData = await response.arrayBuffer()
|
|
}
|
|
}
|
|
async _Decode() {
|
|
if (this._audioBuffer)
|
|
return this._audioBuffer;
|
|
this._audioBuffer = await this._audioDomHandler.DecodeAudioData(this._audioData, this._needsSoftwareDecode);
|
|
this._audioData = null
|
|
}
|
|
async _Load() {
|
|
try {
|
|
this._loadState = "loading";
|
|
await this._Fetch();
|
|
await this._Decode();
|
|
this._loadState = "loaded"
|
|
} catch (err) {
|
|
this._loadState = "failed";
|
|
console.error(`[Construct 3] Failed to load audio '${this._url}': `, err)
|
|
}
|
|
}
|
|
IsLoaded() {
|
|
return !!(this._audioData || this._audioBuffer)
|
|
}
|
|
IsLoadedAndDecoded() {
|
|
return !!this._audioBuffer
|
|
}
|
|
GetAudioBuffer() {
|
|
return this._audioBuffer
|
|
}
|
|
GetDuration() {
|
|
return this._audioBuffer ? this._audioBuffer["duration"] : 0
|
|
}
|
|
}
|
|
}
|
|
;'use strict';
|
|
{
|
|
let nextAiId = 0;
|
|
self.C3AudioInstance = class C3AudioInstance {
|
|
constructor(audioDomHandler, buffer, tag) {
|
|
this._audioDomHandler = audioDomHandler;
|
|
this._buffer = buffer;
|
|
this._tag = tag;
|
|
this._aiId = nextAiId++;
|
|
this._gainNode = this.GetAudioContext()["createGain"]();
|
|
this._gainNode["connect"](this.GetDestinationNode());
|
|
this._pannerNode = null;
|
|
this._isPannerEnabled = false;
|
|
this._isStopped = true;
|
|
this._isPaused = false;
|
|
this._resumeMe = false;
|
|
this._isLooping = false;
|
|
this._volume = 1;
|
|
this._isMuted = false;
|
|
this._playbackRate = 1;
|
|
const timeScaleMode = this._audioDomHandler.GetTimeScaleMode();
|
|
this._isTimescaled = timeScaleMode === 1 && !this.IsMusic() || timeScaleMode === 2;
|
|
this._instUid = -1;
|
|
this._fadeEndTime = -1;
|
|
this._stopOnFadeEnd = false
|
|
}
|
|
Release() {
|
|
this._audioDomHandler = null;
|
|
this._buffer = null;
|
|
if (this._pannerNode) {
|
|
this._pannerNode["disconnect"]();
|
|
this._pannerNode = null
|
|
}
|
|
this._gainNode["disconnect"]();
|
|
this._gainNode = null
|
|
}
|
|
GetAudioContext() {
|
|
return this._audioDomHandler.GetAudioContext()
|
|
}
|
|
GetDestinationNode() {
|
|
return this._audioDomHandler.GetDestinationForTag(this._tag)
|
|
}
|
|
GetMasterVolume() {
|
|
return this._audioDomHandler.GetMasterVolume()
|
|
}
|
|
GetCurrentTime() {
|
|
if (this._isTimescaled)
|
|
return this._audioDomHandler.GetGameTime();
|
|
else
|
|
return performance.now() / 1E3
|
|
}
|
|
GetOriginalUrl() {
|
|
return this._buffer.GetOriginalUrl()
|
|
}
|
|
GetUrl() {
|
|
return this._buffer.GetUrl()
|
|
}
|
|
GetContentType() {
|
|
return this._buffer.GetContentType()
|
|
}
|
|
GetBuffer() {
|
|
return this._buffer
|
|
}
|
|
IsMusic() {
|
|
return this._buffer.IsMusic()
|
|
}
|
|
SetTag(tag) {
|
|
this._tag = tag
|
|
}
|
|
GetTag() {
|
|
return this._tag
|
|
}
|
|
GetAiId() {
|
|
return this._aiId
|
|
}
|
|
HasEnded() {}
|
|
CanBeRecycled() {}
|
|
IsPlaying() {
|
|
return !this._isStopped && !this._isPaused && !this.HasEnded()
|
|
}
|
|
IsActive() {
|
|
return !this._isStopped && !this.HasEnded()
|
|
}
|
|
GetPlaybackTime(applyPlaybackRate) {}
|
|
GetDuration(applyPlaybackRate) {
|
|
let ret = this._buffer.GetDuration();
|
|
if (applyPlaybackRate)
|
|
ret /= this._playbackRate || .001;
|
|
return ret
|
|
}
|
|
Play(isLooping, vol, seekPos, scheduledTime) {}
|
|
Stop() {}
|
|
Pause() {}
|
|
IsPaused() {
|
|
return this._isPaused
|
|
}
|
|
Resume() {}
|
|
SetVolume(v) {
|
|
this._volume = v;
|
|
this._gainNode["gain"]["cancelScheduledValues"](0);
|
|
this._fadeEndTime = -1;
|
|
this._gainNode["gain"]["value"] = this.GetOverallVolume()
|
|
}
|
|
FadeVolume(vol, duration, stopOnEnd) {
|
|
if (this.IsMuted())
|
|
return;
|
|
vol *= this.GetMasterVolume();
|
|
const gainParam = this._gainNode["gain"];
|
|
gainParam["cancelScheduledValues"](0);
|
|
const currentTime = this._audioDomHandler.GetAudioCurrentTime();
|
|
const endTime = currentTime + duration;
|
|
gainParam["setValueAtTime"](gainParam["value"], currentTime);
|
|
gainParam["linearRampToValueAtTime"](vol, endTime);
|
|
this._volume = vol;
|
|
this._fadeEndTime = endTime;
|
|
this._stopOnFadeEnd = stopOnEnd
|
|
}
|
|
_UpdateVolume() {
|
|
this.SetVolume(this._volume)
|
|
}
|
|
Tick(currentTime) {
|
|
if (this._fadeEndTime !== -1 && currentTime >= this._fadeEndTime) {
|
|
this._fadeEndTime = -1;
|
|
if (this._stopOnFadeEnd)
|
|
this.Stop();
|
|
this._audioDomHandler.PostTrigger("fade-ended", this._tag, this._aiId)
|
|
}
|
|
}
|
|
GetOverallVolume() {
|
|
const ret = this._volume * this.GetMasterVolume();
|
|
return isFinite(ret) ? ret : 0
|
|
}
|
|
SetMuted(m) {
|
|
m = !!m;
|
|
if (this._isMuted === m)
|
|
return;
|
|
this._isMuted = m;
|
|
this._UpdateMuted()
|
|
}
|
|
IsMuted() {
|
|
return this._isMuted
|
|
}
|
|
IsSilent() {
|
|
return this._audioDomHandler.IsSilent()
|
|
}
|
|
_UpdateMuted() {}
|
|
SetLooping(l) {}
|
|
IsLooping() {
|
|
return this._isLooping
|
|
}
|
|
SetPlaybackRate(r) {
|
|
if (this._playbackRate === r)
|
|
return;
|
|
this._playbackRate = r;
|
|
this._UpdatePlaybackRate()
|
|
}
|
|
_UpdatePlaybackRate() {}
|
|
GetPlaybackRate() {
|
|
return this._playbackRate
|
|
}
|
|
Seek(pos) {}
|
|
SetSuspended(s) {}
|
|
SetPannerEnabled(e) {
|
|
e = !!e;
|
|
if (this._isPannerEnabled === e)
|
|
return;
|
|
this._isPannerEnabled = e;
|
|
if (this._isPannerEnabled) {
|
|
if (!this._pannerNode) {
|
|
this._pannerNode = this.GetAudioContext()["createPanner"]();
|
|
this._pannerNode["panningModel"] = this._audioDomHandler.GetPanningModel();
|
|
this._pannerNode["distanceModel"] = this._audioDomHandler.GetDistanceModel();
|
|
this._pannerNode["refDistance"] = this._audioDomHandler.GetReferenceDistance();
|
|
this._pannerNode["maxDistance"] = this._audioDomHandler.GetMaxDistance();
|
|
this._pannerNode["rolloffFactor"] = this._audioDomHandler.GetRolloffFactor()
|
|
}
|
|
this._gainNode["disconnect"]();
|
|
this._gainNode["connect"](this._pannerNode);
|
|
this._pannerNode["connect"](this.GetDestinationNode())
|
|
} else {
|
|
this._pannerNode["disconnect"]();
|
|
this._gainNode["disconnect"]();
|
|
this._gainNode["connect"](this.GetDestinationNode())
|
|
}
|
|
}
|
|
SetPan(x, y, angle, innerAngle, outerAngle, outerGain) {
|
|
if (!this._isPannerEnabled)
|
|
return;
|
|
this.SetPanXYA(x, y, angle);
|
|
const toDegrees = self.AudioDOMHandler.ToDegrees;
|
|
this._pannerNode["coneInnerAngle"] = toDegrees(innerAngle);
|
|
this._pannerNode["coneOuterAngle"] = toDegrees(outerAngle);
|
|
this._pannerNode["coneOuterGain"] = outerGain
|
|
}
|
|
SetPanXYA(x, y, angle) {
|
|
if (!this._isPannerEnabled)
|
|
return;
|
|
this._pannerNode["setPosition"](x, y, 0);
|
|
this._pannerNode["setOrientation"](Math.cos(angle), Math.sin(angle), 0)
|
|
}
|
|
SetUID(uid) {
|
|
this._instUid = uid
|
|
}
|
|
GetUID() {
|
|
return this._instUid
|
|
}
|
|
GetResumePosition() {}
|
|
Reconnect(toNode) {
|
|
const outNode = this._pannerNode || this._gainNode;
|
|
outNode["disconnect"]();
|
|
outNode["connect"](toNode)
|
|
}
|
|
GetState() {
|
|
return {
|
|
"aiid": this.GetAiId(),
|
|
"tag": this._tag,
|
|
"duration": this.GetDuration(),
|
|
"volume": this._volume,
|
|
"isPlaying": this.IsPlaying(),
|
|
"playbackTime": this.GetPlaybackTime(),
|
|
"playbackRate": this.GetPlaybackRate(),
|
|
"uid": this._instUid,
|
|
"bufferOriginalUrl": this.GetOriginalUrl(),
|
|
"bufferUrl": "",
|
|
"bufferType": this.GetContentType(),
|
|
"isMusic": this.IsMusic(),
|
|
"isLooping": this.IsLooping(),
|
|
"isMuted": this.IsMuted(),
|
|
"resumePosition": this.GetResumePosition(),
|
|
"pan": this.GetPanState()
|
|
}
|
|
}
|
|
_LoadAdditionalState(d) {
|
|
this.SetPlaybackRate(d["playbackRate"]);
|
|
this.SetMuted(d["isMuted"])
|
|
}
|
|
GetPanState() {
|
|
if (!this._pannerNode)
|
|
return null;
|
|
const pn = this._pannerNode;
|
|
return {
|
|
"pos": [pn["positionX"]["value"], pn["positionY"]["value"], pn["positionZ"]["value"]],
|
|
"orient": [pn["orientationX"]["value"], pn["orientationY"]["value"], pn["orientationZ"]["value"]],
|
|
"cia": pn["coneInnerAngle"],
|
|
"coa": pn["coneOuterAngle"],
|
|
"cog": pn["coneOuterGain"],
|
|
"uid": this._instUid
|
|
}
|
|
}
|
|
LoadPanState(d) {
|
|
if (!d) {
|
|
this.SetPannerEnabled(false);
|
|
return
|
|
}
|
|
this.SetPannerEnabled(true);
|
|
const pn = this._pannerNode;
|
|
pn["setPosition"](...pn["pos"]);
|
|
pn["setOrientation"](...pn["orient"]);
|
|
pn["coneInnerAngle"] = pn["cia"];
|
|
pn["coneOuterAngle"] = pn["coa"];
|
|
pn["coneOuterGain"] = pn["cog"];
|
|
this._instUid = pn["uid"]
|
|
}
|
|
}
|
|
}
|
|
;'use strict';
|
|
{
|
|
self.C3Html5AudioInstance = class C3Html5AudioInstance extends self.C3AudioInstance {
|
|
constructor(audioDomHandler, buffer, tag) {
|
|
super(audioDomHandler, buffer, tag);
|
|
this._buffer.GetOutputNode()["connect"](this._gainNode);
|
|
this._buffer.onended = ()=>this._OnEnded()
|
|
}
|
|
Release() {
|
|
this.Stop();
|
|
this._buffer.GetOutputNode()["disconnect"]();
|
|
super.Release()
|
|
}
|
|
GetAudioElement() {
|
|
return this._buffer.GetAudioElement()
|
|
}
|
|
_OnEnded() {
|
|
this._isStopped = true;
|
|
this._instUid = -1;
|
|
this._audioDomHandler.PostTrigger("ended", this._tag, this._aiId)
|
|
}
|
|
HasEnded() {
|
|
return this.GetAudioElement()["ended"]
|
|
}
|
|
CanBeRecycled() {
|
|
if (this._isStopped)
|
|
return true;
|
|
return this.HasEnded()
|
|
}
|
|
GetPlaybackTime(applyPlaybackRate) {
|
|
let ret = this.GetAudioElement()["currentTime"];
|
|
if (applyPlaybackRate)
|
|
ret *= this._playbackRate;
|
|
if (!this._isLooping)
|
|
ret = Math.min(ret, this.GetDuration());
|
|
return ret
|
|
}
|
|
Play(isLooping, vol, seekPos, scheduledTime) {
|
|
const audioElem = this.GetAudioElement();
|
|
if (audioElem.playbackRate !== 1)
|
|
audioElem.playbackRate = 1;
|
|
if (audioElem.loop !== isLooping)
|
|
audioElem.loop = isLooping;
|
|
this.SetVolume(vol);
|
|
if (audioElem.muted)
|
|
audioElem.muted = false;
|
|
if (audioElem.currentTime !== seekPos)
|
|
try {
|
|
audioElem.currentTime = seekPos
|
|
} catch (err) {
|
|
console.warn(`[Construct 3] Exception seeking audio '${this._buffer.GetUrl()}' to position '${seekPos}': `, err)
|
|
}
|
|
this._audioDomHandler.TryPlayMedia(audioElem);
|
|
this._isStopped = false;
|
|
this._isPaused = false;
|
|
this._isLooping = isLooping;
|
|
this._playbackRate = 1
|
|
}
|
|
Stop() {
|
|
const audioElem = this.GetAudioElement();
|
|
if (!audioElem.paused)
|
|
audioElem.pause();
|
|
this._audioDomHandler.RemovePendingPlay(audioElem);
|
|
this._isStopped = true;
|
|
this._isPaused = false;
|
|
this._instUid = -1
|
|
}
|
|
Pause() {
|
|
if (this._isPaused || this._isStopped || this.HasEnded())
|
|
return;
|
|
const audioElem = this.GetAudioElement();
|
|
if (!audioElem.paused)
|
|
audioElem.pause();
|
|
this._audioDomHandler.RemovePendingPlay(audioElem);
|
|
this._isPaused = true
|
|
}
|
|
Resume() {
|
|
if (!this._isPaused || this._isStopped || this.HasEnded())
|
|
return;
|
|
this._audioDomHandler.TryPlayMedia(this.GetAudioElement());
|
|
this._isPaused = false
|
|
}
|
|
_UpdateMuted() {
|
|
this.GetAudioElement().muted = this._isMuted || this.IsSilent()
|
|
}
|
|
SetLooping(l) {
|
|
l = !!l;
|
|
if (this._isLooping === l)
|
|
return;
|
|
this._isLooping = l;
|
|
this.GetAudioElement().loop = l
|
|
}
|
|
_UpdatePlaybackRate() {
|
|
let r = this._playbackRate;
|
|
if (this._isTimescaled)
|
|
r *= this._audioDomHandler.GetTimeScale();
|
|
try {
|
|
this.GetAudioElement()["playbackRate"] = r
|
|
} catch (err) {
|
|
console.warn(`[Construct 3] Unable to set playback rate '${r}':`, err)
|
|
}
|
|
}
|
|
Seek(pos) {
|
|
if (this._isStopped || this.HasEnded())
|
|
return;
|
|
try {
|
|
this.GetAudioElement()["currentTime"] = pos
|
|
} catch (err) {
|
|
console.warn(`[Construct 3] Error seeking audio to '${pos}': `, err)
|
|
}
|
|
}
|
|
GetResumePosition() {
|
|
return this.GetPlaybackTime()
|
|
}
|
|
SetSuspended(s) {
|
|
if (s)
|
|
if (this.IsPlaying()) {
|
|
this.GetAudioElement()["pause"]();
|
|
this._resumeMe = true
|
|
} else
|
|
this._resumeMe = false;
|
|
else if (this._resumeMe) {
|
|
this._audioDomHandler.TryPlayMedia(this.GetAudioElement());
|
|
this._resumeMe = false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
;'use strict';
|
|
{
|
|
self.C3WebAudioInstance = class C3WebAudioInstance extends self.C3AudioInstance {
|
|
constructor(audioDomHandler, buffer, tag) {
|
|
super(audioDomHandler, buffer, tag);
|
|
this._bufferSource = null;
|
|
this._onended_handler = e=>this._OnEnded(e);
|
|
this._hasPlaybackEnded = true;
|
|
this._activeSource = null;
|
|
this._startTime = 0;
|
|
this._resumePosition = 0;
|
|
this._muteVol = 1
|
|
}
|
|
Release() {
|
|
this.Stop();
|
|
this._ReleaseBufferSource();
|
|
this._onended_handler = null;
|
|
super.Release()
|
|
}
|
|
_ReleaseBufferSource() {
|
|
if (this._bufferSource)
|
|
this._bufferSource["disconnect"]();
|
|
this._bufferSource = null;
|
|
this._activeSource = null
|
|
}
|
|
_OnEnded(e) {
|
|
if (this._isPaused || this._resumeMe)
|
|
return;
|
|
if (e.target !== this._activeSource)
|
|
return;
|
|
this._hasPlaybackEnded = true;
|
|
this._isStopped = true;
|
|
this._instUid = -1;
|
|
this._ReleaseBufferSource();
|
|
this._audioDomHandler.PostTrigger("ended", this._tag, this._aiId)
|
|
}
|
|
HasEnded() {
|
|
if (!this._isStopped && this._bufferSource && this._bufferSource["loop"])
|
|
return false;
|
|
if (this._isPaused)
|
|
return false;
|
|
return this._hasPlaybackEnded
|
|
}
|
|
CanBeRecycled() {
|
|
if (!this._bufferSource || this._isStopped)
|
|
return true;
|
|
return this.HasEnded()
|
|
}
|
|
GetPlaybackTime(applyPlaybackRate) {
|
|
let ret = 0;
|
|
if (this._isPaused)
|
|
ret = this._resumePosition;
|
|
else
|
|
ret = this.GetCurrentTime() - this._startTime;
|
|
if (applyPlaybackRate)
|
|
ret *= this._playbackRate;
|
|
if (!this._isLooping)
|
|
ret = Math.min(ret, this.GetDuration());
|
|
return ret
|
|
}
|
|
Play(isLooping, vol, seekPos, scheduledTime) {
|
|
this._muteVol = 1;
|
|
this.SetVolume(vol);
|
|
this._ReleaseBufferSource();
|
|
this._bufferSource = this.GetAudioContext()["createBufferSource"]();
|
|
this._bufferSource["buffer"] = this._buffer.GetAudioBuffer();
|
|
this._bufferSource["connect"](this._gainNode);
|
|
this._activeSource = this._bufferSource;
|
|
this._bufferSource["onended"] = this._onended_handler;
|
|
this._bufferSource["loop"] = isLooping;
|
|
this._bufferSource["start"](scheduledTime, seekPos);
|
|
this._hasPlaybackEnded = false;
|
|
this._isStopped = false;
|
|
this._isPaused = false;
|
|
this._isLooping = isLooping;
|
|
this._playbackRate = 1;
|
|
this._startTime = this.GetCurrentTime() - seekPos
|
|
}
|
|
Stop() {
|
|
if (this._bufferSource)
|
|
try {
|
|
this._bufferSource["stop"](0)
|
|
} catch (err) {}
|
|
this._isStopped = true;
|
|
this._isPaused = false;
|
|
this._instUid = -1
|
|
}
|
|
Pause() {
|
|
if (this._isPaused || this._isStopped || this.HasEnded())
|
|
return;
|
|
this._resumePosition = this.GetPlaybackTime(true);
|
|
if (this._isLooping)
|
|
this._resumePosition %= this.GetDuration();
|
|
this._isPaused = true;
|
|
this._bufferSource["stop"](0)
|
|
}
|
|
Resume() {
|
|
if (!this._isPaused || this._isStopped || this.HasEnded())
|
|
return;
|
|
this._ReleaseBufferSource();
|
|
this._bufferSource = this.GetAudioContext()["createBufferSource"]();
|
|
this._bufferSource["buffer"] = this._buffer.GetAudioBuffer();
|
|
this._bufferSource["connect"](this._gainNode);
|
|
this._activeSource = this._bufferSource;
|
|
this._bufferSource["onended"] = this._onended_handler;
|
|
this._bufferSource["loop"] = this._isLooping;
|
|
this._UpdateVolume();
|
|
this._UpdatePlaybackRate();
|
|
this._startTime = this.GetCurrentTime() - this._resumePosition / (this._playbackRate || .001);
|
|
this._bufferSource["start"](0, this._resumePosition);
|
|
this._isPaused = false
|
|
}
|
|
GetOverallVolume() {
|
|
return super.GetOverallVolume() * this._muteVol
|
|
}
|
|
_UpdateMuted() {
|
|
this._muteVol = this._isMuted || this.IsSilent() ? 0 : 1;
|
|
this._UpdateVolume()
|
|
}
|
|
SetLooping(l) {
|
|
l = !!l;
|
|
if (this._isLooping === l)
|
|
return;
|
|
this._isLooping = l;
|
|
if (this._bufferSource)
|
|
this._bufferSource["loop"] = l
|
|
}
|
|
_UpdatePlaybackRate() {
|
|
let r = this._playbackRate;
|
|
if (this._isTimescaled)
|
|
r *= this._audioDomHandler.GetTimeScale();
|
|
if (this._bufferSource)
|
|
this._bufferSource["playbackRate"]["value"] = r
|
|
}
|
|
Seek(pos) {
|
|
if (this._isStopped || this.HasEnded())
|
|
return;
|
|
if (this._isPaused)
|
|
this._resumePosition = pos;
|
|
else {
|
|
this.Pause();
|
|
this._resumePosition = pos;
|
|
this.Resume()
|
|
}
|
|
}
|
|
GetResumePosition() {
|
|
return this._resumePosition
|
|
}
|
|
SetSuspended(s) {
|
|
if (s)
|
|
if (this.IsPlaying()) {
|
|
this._resumeMe = true;
|
|
this._resumePosition = this.GetPlaybackTime(true);
|
|
if (this._isLooping)
|
|
this._resumePosition %= this.GetDuration();
|
|
this._bufferSource["stop"](0)
|
|
} else
|
|
this._resumeMe = false;
|
|
else if (this._resumeMe) {
|
|
this._ReleaseBufferSource();
|
|
this._bufferSource = this.GetAudioContext()["createBufferSource"]();
|
|
this._bufferSource["buffer"] = this._buffer.GetAudioBuffer();
|
|
this._bufferSource["connect"](this._gainNode);
|
|
this._activeSource = this._bufferSource;
|
|
this._bufferSource["onended"] = this._onended_handler;
|
|
this._bufferSource["loop"] = this._isLooping;
|
|
this._UpdateVolume();
|
|
this._UpdatePlaybackRate();
|
|
this._startTime = this.GetCurrentTime() - this._resumePosition / (this._playbackRate || .001);
|
|
this._bufferSource["start"](0, this._resumePosition);
|
|
this._resumeMe = false
|
|
}
|
|
}
|
|
_LoadAdditionalState(d) {
|
|
super._LoadAdditionalState(d);
|
|
this._resumePosition = d["resumePosition"]
|
|
}
|
|
}
|
|
}
|
|
;'use strict';
|
|
{
|
|
class AudioFXBase {
|
|
constructor(audioDomHandler) {
|
|
this._audioDomHandler = audioDomHandler;
|
|
this._audioContext = audioDomHandler.GetAudioContext();
|
|
this._index = -1;
|
|
this._tag = "";
|
|
this._type = "";
|
|
this._params = null
|
|
}
|
|
Release() {
|
|
this._audioContext = null
|
|
}
|
|
_SetIndex(i) {
|
|
this._index = i
|
|
}
|
|
GetIndex() {
|
|
return this._index
|
|
}
|
|
_SetTag(t) {
|
|
this._tag = t
|
|
}
|
|
GetTag() {
|
|
return this._tag
|
|
}
|
|
CreateGain() {
|
|
return this._audioContext["createGain"]()
|
|
}
|
|
GetInputNode() {}
|
|
ConnectTo(node) {}
|
|
SetAudioParam(ap, value, ramp, time) {
|
|
ap["cancelScheduledValues"](0);
|
|
if (time === 0) {
|
|
ap["value"] = value;
|
|
return
|
|
}
|
|
const curTime = this._audioContext["currentTime"];
|
|
time += curTime;
|
|
switch (ramp) {
|
|
case 0:
|
|
ap["setValueAtTime"](value, time);
|
|
break;
|
|
case 1:
|
|
ap["setValueAtTime"](ap["value"], curTime);
|
|
ap["linearRampToValueAtTime"](value, time);
|
|
break;
|
|
case 2:
|
|
ap["setValueAtTime"](ap["value"], curTime);
|
|
ap["exponentialRampToValueAtTime"](value, time);
|
|
break
|
|
}
|
|
}
|
|
GetState() {
|
|
return {
|
|
"type": this._type,
|
|
"tag": this._tag,
|
|
"params": this._params
|
|
}
|
|
}
|
|
}
|
|
self.C3AudioFilterFX = class C3AudioFilterFX extends AudioFXBase {
|
|
constructor(audioDomHandler, type, freq, detune, q, gain, mix) {
|
|
super(audioDomHandler);
|
|
this._type = "filter";
|
|
this._params = [type, freq, detune, q, gain, mix];
|
|
this._inputNode = this.CreateGain();
|
|
this._wetNode = this.CreateGain();
|
|
this._wetNode["gain"]["value"] = mix;
|
|
this._dryNode = this.CreateGain();
|
|
this._dryNode["gain"]["value"] = 1 - mix;
|
|
this._filterNode = this._audioContext["createBiquadFilter"]();
|
|
this._filterNode["type"] = type;
|
|
this._filterNode["frequency"]["value"] = freq;
|
|
this._filterNode["detune"]["value"] = detune;
|
|
this._filterNode["Q"]["value"] = q;
|
|
this._filterNode["gain"]["vlaue"] = gain;
|
|
this._inputNode["connect"](this._filterNode);
|
|
this._inputNode["connect"](this._dryNode);
|
|
this._filterNode["connect"](this._wetNode)
|
|
}
|
|
Release() {
|
|
this._inputNode["disconnect"]();
|
|
this._filterNode["disconnect"]();
|
|
this._wetNode["disconnect"]();
|
|
this._dryNode["disconnect"]();
|
|
super.Release()
|
|
}
|
|
ConnectTo(node) {
|
|
this._wetNode["disconnect"]();
|
|
this._wetNode["connect"](node);
|
|
this._dryNode["disconnect"]();
|
|
this._dryNode["connect"](node)
|
|
}
|
|
GetInputNode() {
|
|
return this._inputNode
|
|
}
|
|
SetParam(param, value, ramp, time) {
|
|
switch (param) {
|
|
case 0:
|
|
value = Math.max(Math.min(value / 100, 1), 0);
|
|
this._params[5] = value;
|
|
this.SetAudioParam(this._wetNode["gain"], value, ramp, time);
|
|
this.SetAudioParam(this._dryNode["gain"], 1 - value, ramp, time);
|
|
break;
|
|
case 1:
|
|
this._params[1] = value;
|
|
this.SetAudioParam(this._filterNode["frequency"], value, ramp, time);
|
|
break;
|
|
case 2:
|
|
this._params[2] = value;
|
|
this.SetAudioParam(this._filterNode["detune"], value, ramp, time);
|
|
break;
|
|
case 3:
|
|
this._params[3] = value;
|
|
this.SetAudioParam(this._filterNode["Q"], value, ramp, time);
|
|
break;
|
|
case 4:
|
|
this._params[4] = value;
|
|
this.SetAudioParam(this._filterNode["gain"], value, ramp, time);
|
|
break
|
|
}
|
|
}
|
|
}
|
|
;
|
|
self.C3AudioDelayFX = class C3AudioDelayFX extends AudioFXBase {
|
|
constructor(audioDomHandler, delayTime, delayGain, mix) {
|
|
super(audioDomHandler);
|
|
this._type = "delay";
|
|
this._params = [delayTime, delayGain, mix];
|
|
this._inputNode = this.CreateGain();
|
|
this._wetNode = this.CreateGain();
|
|
this._wetNode["gain"]["value"] = mix;
|
|
this._dryNode = this.CreateGain();
|
|
this._dryNode["gain"]["value"] = 1 - mix;
|
|
this._mainNode = this.CreateGain();
|
|
this._delayNode = this._audioContext["createDelay"](delayTime);
|
|
this._delayNode["delayTime"]["value"] = delayTime;
|
|
this._delayGainNode = this.CreateGain();
|
|
this._delayGainNode["gain"]["value"] = delayGain;
|
|
this._inputNode["connect"](this._mainNode);
|
|
this._inputNode["connect"](this._dryNode);
|
|
this._mainNode["connect"](this._wetNode);
|
|
this._mainNode["connect"](this._delayNode);
|
|
this._delayNode["connect"](this._delayGainNode);
|
|
this._delayGainNode["connect"](this._mainNode)
|
|
}
|
|
Release() {
|
|
this._inputNode["disconnect"]();
|
|
this._wetNode["disconnect"]();
|
|
this._dryNode["disconnect"]();
|
|
this._mainNode["disconnect"]();
|
|
this._delayNode["disconnect"]();
|
|
this._delayGainNode["disconnect"]();
|
|
super.Release()
|
|
}
|
|
ConnectTo(node) {
|
|
this._wetNode["disconnect"]();
|
|
this._wetNode["connect"](node);
|
|
this._dryNode["disconnect"]();
|
|
this._dryNode["connect"](node)
|
|
}
|
|
GetInputNode() {
|
|
return this._inputNode
|
|
}
|
|
SetParam(param, value, ramp, time) {
|
|
const DbToLinear = self.AudioDOMHandler.DbToLinear;
|
|
switch (param) {
|
|
case 0:
|
|
value = Math.max(Math.min(value / 100, 1), 0);
|
|
this._params[2] = value;
|
|
this.SetAudioParam(this._wetNode["gain"], value, ramp, time);
|
|
this.SetAudioParam(this._dryNode["gain"], 1 - value, ramp, time);
|
|
break;
|
|
case 4:
|
|
this._params[1] = DbToLinear(value);
|
|
this.SetAudioParam(this._delayGainNode["gain"], DbToLinear(value), ramp, time);
|
|
break;
|
|
case 5:
|
|
this._params[0] = value;
|
|
this.SetAudioParam(this._delayNode["delayTime"], value, ramp, time);
|
|
break
|
|
}
|
|
}
|
|
}
|
|
;
|
|
self.C3AudioConvolveFX = class C3AudioConvolveFX extends AudioFXBase {
|
|
constructor(audioDomHandler, buffer, normalize, mix) {
|
|
super(audioDomHandler);
|
|
this._type = "convolution";
|
|
this._params = [normalize, mix];
|
|
this._bufferOriginalUrl = "";
|
|
this._bufferUrl = "";
|
|
this._bufferType = "";
|
|
this._inputNode = this.CreateGain();
|
|
this._wetNode = this.CreateGain();
|
|
this._wetNode["gain"]["value"] = mix;
|
|
this._dryNode = this.CreateGain();
|
|
this._dryNode["gain"]["value"] = 1 - mix;
|
|
this._convolveNode = this._audioContext["createConvolver"]();
|
|
this._convolveNode["normalize"] = normalize;
|
|
this._convolveNode["buffer"] = buffer;
|
|
this._inputNode["connect"](this._convolveNode);
|
|
this._inputNode["connect"](this._dryNode);
|
|
this._convolveNode["connect"](this._wetNode)
|
|
}
|
|
Release() {
|
|
this._inputNode["disconnect"]();
|
|
this._convolveNode["disconnect"]();
|
|
this._wetNode["disconnect"]();
|
|
this._dryNode["disconnect"]();
|
|
super.Release()
|
|
}
|
|
ConnectTo(node) {
|
|
this._wetNode["disconnect"]();
|
|
this._wetNode["connect"](node);
|
|
this._dryNode["disconnect"]();
|
|
this._dryNode["connect"](node)
|
|
}
|
|
GetInputNode() {
|
|
return this._inputNode
|
|
}
|
|
SetParam(param, value, ramp, time) {
|
|
switch (param) {
|
|
case 0:
|
|
value = Math.max(Math.min(value / 100, 1), 0);
|
|
this._params[1] = value;
|
|
this.SetAudioParam(this._wetNode["gain"], value, ramp, time);
|
|
this.SetAudioParam(this._dryNode["gain"], 1 - value, ramp, time);
|
|
break
|
|
}
|
|
}
|
|
_SetBufferInfo(bufferOriginalUrl, bufferUrl, bufferType) {
|
|
this._bufferOriginalUrl = bufferOriginalUrl;
|
|
this._bufferUrl = bufferUrl;
|
|
this._bufferType = bufferType
|
|
}
|
|
GetState() {
|
|
const ret = super.GetState();
|
|
ret["bufferOriginalUrl"] = this._bufferOriginalUrl;
|
|
ret["bufferUrl"] = "";
|
|
ret["bufferType"] = this._bufferType;
|
|
return ret
|
|
}
|
|
}
|
|
;
|
|
self.C3AudioFlangerFX = class C3AudioFlangerFX extends AudioFXBase {
|
|
constructor(audioDomHandler, delay, modulation, freq, feedback, mix) {
|
|
super(audioDomHandler);
|
|
this._type = "flanger";
|
|
this._params = [delay, modulation, freq, feedback, mix];
|
|
this._inputNode = this.CreateGain();
|
|
this._dryNode = this.CreateGain();
|
|
this._dryNode["gain"]["value"] = 1 - mix / 2;
|
|
this._wetNode = this.CreateGain();
|
|
this._wetNode["gain"]["value"] = mix / 2;
|
|
this._feedbackNode = this.CreateGain();
|
|
this._feedbackNode["gain"]["value"] = feedback;
|
|
this._delayNode = this._audioContext["createDelay"](delay + modulation);
|
|
this._delayNode["delayTime"]["value"] = delay;
|
|
this._oscNode = this._audioContext["createOscillator"]();
|
|
this._oscNode["frequency"]["value"] = freq;
|
|
this._oscGainNode = this.CreateGain();
|
|
this._oscGainNode["gain"]["value"] = modulation;
|
|
this._inputNode["connect"](this._delayNode);
|
|
this._inputNode["connect"](this._dryNode);
|
|
this._delayNode["connect"](this._wetNode);
|
|
this._delayNode["connect"](this._feedbackNode);
|
|
this._feedbackNode["connect"](this._delayNode);
|
|
this._oscNode["connect"](this._oscGainNode);
|
|
this._oscGainNode["connect"](this._delayNode["delayTime"]);
|
|
this._oscNode["start"](0)
|
|
}
|
|
Release() {
|
|
this._oscNode["stop"](0);
|
|
this._inputNode["disconnect"]();
|
|
this._delayNode["disconnect"]();
|
|
this._oscNode["disconnect"]();
|
|
this._oscGainNode["disconnect"]();
|
|
this._dryNode["disconnect"]();
|
|
this._wetNode["disconnect"]();
|
|
this._feedbackNode["disconnect"]();
|
|
super.Release()
|
|
}
|
|
ConnectTo(node) {
|
|
this._wetNode["disconnect"]();
|
|
this._wetNode["connect"](node);
|
|
this._dryNode["disconnect"]();
|
|
this._dryNode["connect"](node)
|
|
}
|
|
GetInputNode() {
|
|
return this._inputNode
|
|
}
|
|
SetParam(param, value, ramp, time) {
|
|
switch (param) {
|
|
case 0:
|
|
value = Math.max(Math.min(value / 100, 1), 0);
|
|
this._params[4] = value;
|
|
this.SetAudioParam(this._wetNode["gain"], value / 2, ramp, time);
|
|
this.SetAudioParam(this._dryNode["gain"], 1 - value / 2, ramp, time);
|
|
break;
|
|
case 6:
|
|
this._params[1] = value / 1E3;
|
|
this.SetAudioParam(this._oscGainNode["gain"], value / 1E3, ramp, time);
|
|
break;
|
|
case 7:
|
|
this._params[2] = value;
|
|
this.SetAudioParam(this._oscNode["frequency"], value, ramp, time);
|
|
break;
|
|
case 8:
|
|
this._params[3] = value / 100;
|
|
this.SetAudioParam(this._feedbackNode["gain"], value / 100, ramp, time);
|
|
break
|
|
}
|
|
}
|
|
}
|
|
;
|
|
self.C3AudioPhaserFX = class C3AudioPhaserFX extends AudioFXBase {
|
|
constructor(audioDomHandler, freq, detune, q, modulation, modfreq, mix) {
|
|
super(audioDomHandler);
|
|
this._type = "phaser";
|
|
this._params = [freq, detune, q, modulation, modfreq, mix];
|
|
this._inputNode = this.CreateGain();
|
|
this._dryNode = this.CreateGain();
|
|
this._dryNode["gain"]["value"] = 1 - mix / 2;
|
|
this._wetNode = this.CreateGain();
|
|
this._wetNode["gain"]["value"] = mix / 2;
|
|
this._filterNode = this._audioContext["createBiquadFilter"]();
|
|
this._filterNode["type"] = "allpass";
|
|
this._filterNode["frequency"]["value"] = freq;
|
|
this._filterNode["detune"]["value"] = detune;
|
|
this._filterNode["Q"]["value"] = q;
|
|
this._oscNode = this._audioContext["createOscillator"]();
|
|
this._oscNode["frequency"]["value"] = modfreq;
|
|
this._oscGainNode = this.CreateGain();
|
|
this._oscGainNode["gain"]["value"] = modulation;
|
|
this._inputNode["connect"](this._filterNode);
|
|
this._inputNode["connect"](this._dryNode);
|
|
this._filterNode["connect"](this._wetNode);
|
|
this._oscNode["connect"](this._oscGainNode);
|
|
this._oscGainNode["connect"](this._filterNode["frequency"]);
|
|
this._oscNode["start"](0)
|
|
}
|
|
Release() {
|
|
this._oscNode["stop"](0);
|
|
this._inputNode["disconnect"]();
|
|
this._filterNode["disconnect"]();
|
|
this._oscNode["disconnect"]();
|
|
this._oscGainNode["disconnect"]();
|
|
this._dryNode["disconnect"]();
|
|
this._wetNode["disconnect"]();
|
|
super.Release()
|
|
}
|
|
ConnectTo(node) {
|
|
this._wetNode["disconnect"]();
|
|
this._wetNode["connect"](node);
|
|
this._dryNode["disconnect"]();
|
|
this._dryNode["connect"](node)
|
|
}
|
|
GetInputNode() {
|
|
return this._inputNode
|
|
}
|
|
SetParam(param, value, ramp, time) {
|
|
switch (param) {
|
|
case 0:
|
|
value = Math.max(Math.min(value / 100, 1), 0);
|
|
this._params[5] = value;
|
|
this.SetAudioParam(this._wetNode["gain"], value / 2, ramp, time);
|
|
this.SetAudioParam(this._dryNode["gain"], 1 - value / 2, ramp, time);
|
|
break;
|
|
case 1:
|
|
this._params[0] = value;
|
|
this.SetAudioParam(this._filterNode["frequency"], value, ramp, time);
|
|
break;
|
|
case 2:
|
|
this._params[1] = value;
|
|
this.SetAudioParam(this._filterNode["detune"], value, ramp, time);
|
|
break;
|
|
case 3:
|
|
this._params[2] = value;
|
|
this.SetAudioParam(this._filterNode["Q"], value, ramp, time);
|
|
break;
|
|
case 6:
|
|
this._params[3] = value;
|
|
this.SetAudioParam(this._oscGainNode["gain"], value, ramp, time);
|
|
break;
|
|
case 7:
|
|
this._params[4] = value;
|
|
this.SetAudioParam(this._oscNode["frequency"], value, ramp, time);
|
|
break
|
|
}
|
|
}
|
|
}
|
|
;
|
|
self.C3AudioGainFX = class C3AudioGainFX extends AudioFXBase {
|
|
constructor(audioDomHandler, g) {
|
|
super(audioDomHandler);
|
|
this._type = "gain";
|
|
this._params = [g];
|
|
this._node = this.CreateGain();
|
|
this._node["gain"]["value"] = g
|
|
}
|
|
Release() {
|
|
this._node["disconnect"]();
|
|
super.Release()
|
|
}
|
|
ConnectTo(node) {
|
|
this._node["disconnect"]();
|
|
this._node["connect"](node)
|
|
}
|
|
GetInputNode() {
|
|
return this._node
|
|
}
|
|
SetParam(param, value, ramp, time) {
|
|
const DbToLinear = self.AudioDOMHandler.DbToLinear;
|
|
switch (param) {
|
|
case 4:
|
|
this._params[0] = DbToLinear(value);
|
|
this.SetAudioParam(this._node["gain"], DbToLinear(value), ramp, time);
|
|
break
|
|
}
|
|
}
|
|
}
|
|
;
|
|
self.C3AudioTremoloFX = class C3AudioTremoloFX extends AudioFXBase {
|
|
constructor(audioDomHandler, freq, mix) {
|
|
super(audioDomHandler);
|
|
this._type = "tremolo";
|
|
this._params = [freq, mix];
|
|
this._node = this.CreateGain();
|
|
this._node["gain"]["value"] = 1 - mix / 2;
|
|
this._oscNode = this._audioContext["createOscillator"]();
|
|
this._oscNode["frequency"]["value"] = freq;
|
|
this._oscGainNode = this.CreateGain();
|
|
this._oscGainNode["gain"]["value"] = mix / 2;
|
|
this._oscNode["connect"](this._oscGainNode);
|
|
this._oscGainNode["connect"](this._node["gain"]);
|
|
this._oscNode["start"](0)
|
|
}
|
|
Release() {
|
|
this._oscNode["stop"](0);
|
|
this._oscNode["disconnect"]();
|
|
this._oscGainNode["disconnect"]();
|
|
this._node["disconnect"]();
|
|
super.Release()
|
|
}
|
|
ConnectTo(node) {
|
|
this._node["disconnect"]();
|
|
this._node["connect"](node)
|
|
}
|
|
GetInputNode() {
|
|
return this._node
|
|
}
|
|
SetParam(param, value, ramp, time) {
|
|
switch (param) {
|
|
case 0:
|
|
value = Math.max(Math.min(value / 100, 1), 0);
|
|
this._params[1] = value;
|
|
this.SetAudioParam(this._node["gain"]["value"], 1 - value / 2, ramp, time);
|
|
this.SetAudioParam(this._oscGainNode["gain"]["value"], value / 2, ramp, time);
|
|
break;
|
|
case 7:
|
|
this._params[0] = value;
|
|
this.SetAudioParam(this._oscNode["frequency"], value, ramp, time);
|
|
break
|
|
}
|
|
}
|
|
}
|
|
;
|
|
self.C3AudioRingModFX = class C3AudioRingModFX extends AudioFXBase {
|
|
constructor(audioDomHandler, freq, mix) {
|
|
super(audioDomHandler);
|
|
this._type = "ringmod";
|
|
this._params = [freq, mix];
|
|
this._inputNode = this.CreateGain();
|
|
this._wetNode = this.CreateGain();
|
|
this._wetNode["gain"]["value"] = mix;
|
|
this._dryNode = this.CreateGain();
|
|
this._dryNode["gain"]["value"] = 1 - mix;
|
|
this._ringNode = this.CreateGain();
|
|
this._ringNode["gain"]["value"] = 0;
|
|
this._oscNode = this._audioContext["createOscillator"]();
|
|
this._oscNode["frequency"]["value"] = freq;
|
|
this._oscNode["connect"](this._ringNode["gain"]);
|
|
this._oscNode["start"](0);
|
|
this._inputNode["connect"](this._ringNode);
|
|
this._inputNode["connect"](this._dryNode);
|
|
this._ringNode["connect"](this._wetNode)
|
|
}
|
|
Release() {
|
|
this._oscNode["stop"](0);
|
|
this._oscNode["disconnect"]();
|
|
this._ringNode["disconnect"]();
|
|
this._inputNode["disconnect"]();
|
|
this._wetNode["disconnect"]();
|
|
this._dryNode["disconnect"]();
|
|
super.Release()
|
|
}
|
|
ConnectTo(node) {
|
|
this._wetNode["disconnect"]();
|
|
this._wetNode["connect"](node);
|
|
this._dryNode["disconnect"]();
|
|
this._dryNode["connect"](node)
|
|
}
|
|
GetInputNode() {
|
|
return this._inputNode
|
|
}
|
|
SetParam(param, value, ramp, time) {
|
|
switch (param) {
|
|
case 0:
|
|
value = Math.max(Math.min(value / 100, 1), 0);
|
|
this._params[1] = value;
|
|
this.SetAudioParam(this._wetNode["gain"], value, ramp, time);
|
|
this.SetAudioParam(this._dryNode["gain"], 1 - value, ramp, time);
|
|
break;
|
|
case 7:
|
|
this._params[0] = value;
|
|
this.SetAudioParam(this._oscNode["frequency"], value, ramp, time);
|
|
break
|
|
}
|
|
}
|
|
}
|
|
;
|
|
self.C3AudioDistortionFX = class C3AudioDistortionFX extends AudioFXBase {
|
|
constructor(audioDomHandler, threshold, headroom, drive, makeupgain, mix) {
|
|
super(audioDomHandler);
|
|
this._type = "distortion";
|
|
this._params = [threshold, headroom, drive, makeupgain, mix];
|
|
this._inputNode = this.CreateGain();
|
|
this._preGain = this.CreateGain();
|
|
this._postGain = this.CreateGain();
|
|
this._SetDrive(drive, makeupgain);
|
|
this._wetNode = this.CreateGain();
|
|
this._wetNode["gain"]["value"] = mix;
|
|
this._dryNode = this.CreateGain();
|
|
this._dryNode["gain"]["value"] = 1 - mix;
|
|
this._waveShaper = this._audioContext["createWaveShaper"]();
|
|
this._curve = new Float32Array(65536);
|
|
this._GenerateColortouchCurve(threshold, headroom);
|
|
this._waveShaper.curve = this._curve;
|
|
this._inputNode["connect"](this._preGain);
|
|
this._inputNode["connect"](this._dryNode);
|
|
this._preGain["connect"](this._waveShaper);
|
|
this._waveShaper["connect"](this._postGain);
|
|
this._postGain["connect"](this._wetNode)
|
|
}
|
|
Release() {
|
|
this._inputNode["disconnect"]();
|
|
this._preGain["disconnect"]();
|
|
this._waveShaper["disconnect"]();
|
|
this._postGain["disconnect"]();
|
|
this._wetNode["disconnect"]();
|
|
this._dryNode["disconnect"]();
|
|
super.Release()
|
|
}
|
|
_SetDrive(drive, makeupgain) {
|
|
if (drive < .01)
|
|
drive = .01;
|
|
this._preGain["gain"]["value"] = drive;
|
|
this._postGain["gain"]["value"] = Math.pow(1 / drive, .6) * makeupgain
|
|
}
|
|
_GenerateColortouchCurve(threshold, headroom) {
|
|
const n = 65536;
|
|
const n2 = n / 2;
|
|
for (let i = 0; i < n2; ++i) {
|
|
let x = i / n2;
|
|
x = this._Shape(x, threshold, headroom);
|
|
this._curve[n2 + i] = x;
|
|
this._curve[n2 - i - 1] = -x
|
|
}
|
|
}
|
|
_Shape(x, threshold, headroom) {
|
|
const maximum = 1.05 * headroom * threshold;
|
|
const kk = maximum - threshold;
|
|
const sign = x < 0 ? -1 : +1;
|
|
const absx = x < 0 ? -x : x;
|
|
let shapedInput = absx < threshold ? absx : threshold + kk * self.AudioDOMHandler.e4(absx - threshold, 1 / kk);
|
|
shapedInput *= sign;
|
|
return shapedInput
|
|
}
|
|
ConnectTo(node) {
|
|
this._wetNode["disconnect"]();
|
|
this._wetNode["connect"](node);
|
|
this._dryNode["disconnect"]();
|
|
this._dryNode["connect"](node)
|
|
}
|
|
GetInputNode() {
|
|
return this._inputNode
|
|
}
|
|
SetParam(param, value, ramp, time) {
|
|
switch (param) {
|
|
case 0:
|
|
value = Math.max(Math.min(value / 100, 1), 0);
|
|
this._params[4] = value;
|
|
this.SetAudioParam(this._wetNode["gain"], value, ramp, time);
|
|
this.SetAudioParam(this._dryNode["gain"], 1 - value, ramp, time);
|
|
break
|
|
}
|
|
}
|
|
}
|
|
;
|
|
self.C3AudioCompressorFX = class C3AudioCompressorFX extends AudioFXBase {
|
|
constructor(audioDomHandler, threshold, knee, ratio, attack, release) {
|
|
super(audioDomHandler);
|
|
this._type = "compressor";
|
|
this._params = [threshold, knee, ratio, attack, release];
|
|
this._node = this._audioContext["createDynamicsCompressor"]();
|
|
this._node["threshold"]["value"] = threshold;
|
|
this._node["knee"]["value"] = knee;
|
|
this._node["ratio"]["value"] = ratio;
|
|
this._node["attack"]["value"] = attack;
|
|
this._node["release"]["value"] = release
|
|
}
|
|
Release() {
|
|
this._node["disconnect"]();
|
|
super.Release()
|
|
}
|
|
ConnectTo(node) {
|
|
this._node["disconnect"]();
|
|
this._node["connect"](node)
|
|
}
|
|
GetInputNode() {
|
|
return this._node
|
|
}
|
|
SetParam(param, value, ramp, time) {}
|
|
}
|
|
;
|
|
self.C3AudioAnalyserFX = class C3AudioAnalyserFX extends AudioFXBase {
|
|
constructor(audioDomHandler, fftSize, smoothing) {
|
|
super(audioDomHandler);
|
|
this._type = "analyser";
|
|
this._params = [fftSize, smoothing];
|
|
this._node = this._audioContext["createAnalyser"]();
|
|
this._node["fftSize"] = fftSize;
|
|
this._node["smoothingTimeConstant"] = smoothing;
|
|
this._freqBins = new Float32Array(this._node["frequencyBinCount"]);
|
|
this._signal = new Uint8Array(fftSize);
|
|
this._peak = 0;
|
|
this._rms = 0;
|
|
this._audioDomHandler._AddAnalyser(this)
|
|
}
|
|
Release() {
|
|
this._audioDomHandler._RemoveAnalyser(this);
|
|
this._node["disconnect"]();
|
|
super.Release()
|
|
}
|
|
Tick() {
|
|
this._node["getFloatFrequencyData"](this._freqBins);
|
|
this._node["getByteTimeDomainData"](this._signal);
|
|
const fftSize = this._node["fftSize"];
|
|
this._peak = 0;
|
|
let rmsSquaredSum = 0;
|
|
for (let i = 0; i < fftSize; ++i) {
|
|
let s = (this._signal[i] - 128) / 128;
|
|
if (s < 0)
|
|
s = -s;
|
|
if (this._peak < s)
|
|
this._peak = s;
|
|
rmsSquaredSum += s * s
|
|
}
|
|
const LinearToDb = self.AudioDOMHandler.LinearToDb;
|
|
this._peak = LinearToDb(this._peak);
|
|
this._rms = LinearToDb(Math.sqrt(rmsSquaredSum / fftSize))
|
|
}
|
|
ConnectTo(node) {
|
|
this._node["disconnect"]();
|
|
this._node["connect"](node)
|
|
}
|
|
GetInputNode() {
|
|
return this._node
|
|
}
|
|
SetParam(param, value, ramp, time) {}
|
|
GetData() {
|
|
return {
|
|
"tag": this.GetTag(),
|
|
"index": this.GetIndex(),
|
|
"peak": this._peak,
|
|
"rms": this._rms,
|
|
"binCount": this._node["frequencyBinCount"],
|
|
"freqBins": this._freqBins
|
|
}
|
|
}
|
|
}
|
|
}
|
|
;'use strict';
|
|
{
|
|
const DOM_COMPONENT_ID = "text-input";
|
|
function StopPropagation(e) {
|
|
e.stopPropagation()
|
|
}
|
|
function StopKeyPropagation(e) {
|
|
if (e.which !== 13 && e.which !== 27)
|
|
e.stopPropagation()
|
|
}
|
|
const HANDLER_CLASS = class TextInputDOMHandler extends self.DOMElementHandler {
|
|
constructor(iRuntime) {
|
|
super(iRuntime, DOM_COMPONENT_ID);
|
|
this.AddDOMElementMessageHandler("scroll-to-bottom", elem=>this._OnScrollToBottom(elem))
|
|
}
|
|
CreateElement(elementId, e) {
|
|
let elem;
|
|
const type = e["type"];
|
|
if (type === "textarea") {
|
|
elem = document.createElement("textarea");
|
|
elem.style.resize = "none"
|
|
} else {
|
|
elem = document.createElement("input");
|
|
elem.type = type
|
|
}
|
|
elem.style.position = "absolute";
|
|
elem.autocomplete = "off";
|
|
elem.addEventListener("touchstart", StopPropagation);
|
|
elem.addEventListener("touchmove", StopPropagation);
|
|
elem.addEventListener("touchend", StopPropagation);
|
|
elem.addEventListener("mousedown", StopPropagation);
|
|
elem.addEventListener("mouseup", StopPropagation);
|
|
elem.addEventListener("keydown", StopKeyPropagation);
|
|
elem.addEventListener("keyup", StopKeyPropagation);
|
|
elem.addEventListener("click", e=>{
|
|
e.stopPropagation();
|
|
this._PostToRuntimeElementMaybeSync("click", elementId)
|
|
}
|
|
);
|
|
elem.addEventListener("dblclick", e=>{
|
|
e.stopPropagation();
|
|
this._PostToRuntimeElementMaybeSync("dblclick", elementId)
|
|
}
|
|
);
|
|
elem.addEventListener("input", ()=>this.PostToRuntimeElement("change", elementId, {
|
|
"text": elem.value
|
|
}));
|
|
if (e["id"])
|
|
elem.id = e["id"];
|
|
this.UpdateState(elem, e);
|
|
return elem
|
|
}
|
|
UpdateState(elem, e) {
|
|
elem.value = e["text"];
|
|
elem.placeholder = e["placeholder"];
|
|
elem.title = e["title"];
|
|
elem.disabled = !e["isEnabled"];
|
|
elem.readOnly = e["isReadOnly"];
|
|
elem.spellcheck = e["spellCheck"];
|
|
const maxLength = e["maxLength"];
|
|
if (maxLength < 0)
|
|
elem.removeAttribute("maxlength");
|
|
else
|
|
elem.setAttribute("maxlength", maxLength)
|
|
}
|
|
_OnScrollToBottom(elem) {
|
|
elem.scrollTop = elem.scrollHeight
|
|
}
|
|
}
|
|
;
|
|
self.RuntimeInterface.AddDOMHandlerClass(HANDLER_CLASS)
|
|
}
|
|
; |